agent-facets 0.3.0 → 0.3.5

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__/launcher.test.ts

@@ -1,106 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
-import { chmod, mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join, resolve } from 'node:path'
-
-const LAUNCHER_PATH = resolve(import.meta.dir, '..', '..', 'bin', 'facet')
-
-interface ExecResult {
-  stdout: string
-  stderr: string
-  exitCode: number
-}
-
-async function runLauncher(args: string[] = [], env: Record<string, string> = {}): Promise<ExecResult> {
-  const proc = Bun.spawn(['node', LAUNCHER_PATH, ...args], {
-    env: { ...process.env, ...env },
-    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, stderr, exitCode }
-}
-
-describe('launcher — FACET_BIN_PATH override', () => {
-  let tmpDir: string
-  let mockBinaryPath: string
-
-  beforeAll(async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'launcher-test-'))
-    mockBinaryPath = join(tmpDir, 'mock-facet')
-    await writeFile(mockBinaryPath, '#!/bin/sh\necho "mock-facet: $@"\n')
-    await chmod(mockBinaryPath, 0o755)
-  })
-
-  afterAll(async () => {
-    await rm(tmpDir, { recursive: true, force: true })
-  })
-
-  test('runs the binary at FACET_BIN_PATH', async () => {
-    const result = await runLauncher(['--version'], { FACET_BIN_PATH: mockBinaryPath })
-    expect(result.stdout).toContain('mock-facet:')
-    expect(result.exitCode).toBe(0)
-  })
-
-  test('forwards arguments to the target binary', async () => {
-    const result = await runLauncher(['build', '--force', 'my-dir'], { FACET_BIN_PATH: mockBinaryPath })
-    expect(result.stdout).toContain('build --force my-dir')
-  })
-})
-
-describe('launcher — forwards exit code', () => {
-  let tmpDir: string
-  let exitingBinaryPath: string
-
-  beforeAll(async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'launcher-exit-'))
-    exitingBinaryPath = join(tmpDir, 'exit-42')
-    await writeFile(exitingBinaryPath, '#!/bin/sh\nexit 42\n')
-    await chmod(exitingBinaryPath, 0o755)
-  })
-
-  afterAll(async () => {
-    await rm(tmpDir, { recursive: true, force: true })
-  })
-
-  test('exits with the same code as the target binary', async () => {
-    const result = await runLauncher([], { FACET_BIN_PATH: exitingBinaryPath })
-    expect(result.exitCode).toBe(42)
-  })
-})
-
-describe('launcher — no binary found', () => {
-  let tmpDir: string
-  let isolatedLauncherPath: string
-
-  beforeAll(async () => {
-    // Create an isolated copy of the launcher in a directory with no node_modules
-    // and no .facet, so resolution falls through to the error path.
-    tmpDir = await mkdtemp(join(tmpdir(), 'launcher-nobin-'))
-    isolatedLauncherPath = join(tmpDir, 'facet')
-    await Bun.write(isolatedLauncherPath, await Bun.file(LAUNCHER_PATH).text())
-    await chmod(isolatedLauncherPath, 0o755)
-  })
-
-  afterAll(async () => {
-    await rm(tmpDir, { recursive: true, force: true })
-  })
-
-  test('prints error with candidate package names and exits 1', async () => {
-    const proc = Bun.spawn(['node', isolatedLauncherPath], {
-      env: { ...process.env, FACET_BIN_PATH: undefined },
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
-
-    const stderr = await new Response(proc.stderr).text()
-    const exitCode = await proc.exited
-
-    expect(exitCode).toBe(1)
-    expect(stderr).toContain('agent-facets-')
-    expect(stderr).toContain('package manager failed')
-  })
-})

package/src/__tests__/postinstall.test.ts

@@ -1,196 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { resolve } from 'node:path'
-
-// Import the pure functions from the postinstall script
-const postinstallPath = resolve(import.meta.dir, '..', '..', 'scripts', 'postinstall.mjs')
-const { buildCandidates, detectPlatform } = await import(postinstallPath)
-
-describe('detectPlatform', () => {
-  test('returns an object with platform and arch strings', () => {
-    const result = detectPlatform()
-    expect(typeof result.platform).toBe('string')
-    expect(typeof result.arch).toBe('string')
-    expect(result.platform.length).toBeGreaterThan(0)
-    expect(result.arch.length).toBeGreaterThan(0)
-  })
-
-  test('maps darwin correctly', () => {
-    // We're running on macOS in this project
-    const result = detectPlatform()
-    if (process.platform === 'darwin') {
-      expect(result.platform).toBe('darwin')
-    }
-  })
-})
-
-describe('buildCandidates', () => {
-  // ---------------------------------------------------------------------------
-  // Linux glibc
-  // ---------------------------------------------------------------------------
-
-  test('linux x64 avx2 glibc', () => {
-    const result = buildCandidates('linux', 'x64', { avx2: true, musl: false })
-    expect(result).toEqual([
-      'agent-facets-linux-x64',
-      'agent-facets-linux-x64-baseline',
-      'agent-facets-linux-x64-musl',
-      'agent-facets-linux-x64-baseline-musl',
-    ])
-  })
-
-  test('linux x64 no-avx2 glibc', () => {
-    const result = buildCandidates('linux', 'x64', { avx2: false, musl: false })
-    expect(result).toEqual([
-      'agent-facets-linux-x64-baseline',
-      'agent-facets-linux-x64',
-      'agent-facets-linux-x64-baseline-musl',
-      'agent-facets-linux-x64-musl',
-    ])
-  })
-
-  test('linux arm64 glibc', () => {
-    const result = buildCandidates('linux', 'arm64', { avx2: false, musl: false })
-    expect(result).toEqual(['agent-facets-linux-arm64', 'agent-facets-linux-arm64-musl'])
-  })
-
-  // ---------------------------------------------------------------------------
-  // Linux musl
-  // ---------------------------------------------------------------------------
-
-  test('linux x64 avx2 musl', () => {
-    const result = buildCandidates('linux', 'x64', { avx2: true, musl: true })
-    expect(result).toEqual([
-      'agent-facets-linux-x64-musl',
-      'agent-facets-linux-x64-baseline-musl',
-      'agent-facets-linux-x64',
-      'agent-facets-linux-x64-baseline',
-    ])
-  })
-
-  test('linux x64 no-avx2 musl', () => {
-    const result = buildCandidates('linux', 'x64', { avx2: false, musl: true })
-    expect(result).toEqual([
-      'agent-facets-linux-x64-baseline-musl',
-      'agent-facets-linux-x64-musl',
-      'agent-facets-linux-x64-baseline',
-      'agent-facets-linux-x64',
-    ])
-  })
-
-  test('linux arm64 musl', () => {
-    const result = buildCandidates('linux', 'arm64', { avx2: false, musl: true })
-    expect(result).toEqual(['agent-facets-linux-arm64-musl', 'agent-facets-linux-arm64'])
-  })
-
-  // ---------------------------------------------------------------------------
-  // Non-Linux
-  // ---------------------------------------------------------------------------
-
-  test('darwin arm64', () => {
-    const result = buildCandidates('darwin', 'arm64', { avx2: false })
-    expect(result).toEqual(['agent-facets-darwin-arm64'])
-  })
-
-  test('darwin x64 avx2', () => {
-    const result = buildCandidates('darwin', 'x64', { avx2: true })
-    expect(result).toEqual(['agent-facets-darwin-x64', 'agent-facets-darwin-x64-baseline'])
-  })
-
-  test('darwin x64 no-avx2', () => {
-    const result = buildCandidates('darwin', 'x64', { avx2: false })
-    expect(result).toEqual(['agent-facets-darwin-x64-baseline', 'agent-facets-darwin-x64'])
-  })
-
-  test('windows x64 avx2', () => {
-    const result = buildCandidates('windows', 'x64', { avx2: true })
-    expect(result).toEqual(['agent-facets-windows-x64', 'agent-facets-windows-x64-baseline'])
-  })
-
-  test('windows arm64', () => {
-    const result = buildCandidates('windows', 'arm64', { avx2: false })
-    expect(result).toEqual(['agent-facets-windows-arm64'])
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Consistency: launcher and postinstall must produce identical candidate lists
-// ---------------------------------------------------------------------------
-
-describe('consistency — launcher and postinstall candidate lists match', () => {
-  /**
-   * Reimplements the launcher's candidate-building logic as a pure function.
-   * This is intentionally a direct translation of the CommonJS code in bin/facet
-   * so the test catches any drift between the two implementations.
-   */
-  function launcherCandidates(platform: string, arch: string, opts: { avx2: boolean; musl?: boolean }): string[] {
-    const base = `agent-facets-${platform}-${arch}`
-    const baseline = arch === 'x64' && !opts.avx2
-
-    if (platform === 'linux') {
-      const musl = !!opts.musl
-
-      if (musl) {
-        if (arch === 'x64') {
-          if (baseline) return [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base]
-          return [`${base}-musl`, `${base}-baseline-musl`, base, `${base}-baseline`]
-        }
-        return [`${base}-musl`, base]
-      }
-
-      if (arch === 'x64') {
-        if (baseline) return [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
-        return [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`]
-      }
-      return [base, `${base}-musl`]
-    }
-
-    if (arch === 'x64') {
-      if (baseline) return [`${base}-baseline`, base]
-      return [base, `${base}-baseline`]
-    }
-    return [base]
-  }
-
-  const cases: Array<{ platform: string; arch: string; avx2: boolean; musl?: boolean }> = [
-    // Linux glibc
-    { platform: 'linux', arch: 'x64', avx2: true, musl: false },
-    { platform: 'linux', arch: 'x64', avx2: false, musl: false },
-    { platform: 'linux', arch: 'arm64', avx2: false, musl: false },
-    // Linux musl
-    { platform: 'linux', arch: 'x64', avx2: true, musl: true },
-    { platform: 'linux', arch: 'x64', avx2: false, musl: true },
-    { platform: 'linux', arch: 'arm64', avx2: false, musl: true },
-    // Darwin
-    { platform: 'darwin', arch: 'arm64', avx2: false },
-    { platform: 'darwin', arch: 'x64', avx2: true },
-    { platform: 'darwin', arch: 'x64', avx2: false },
-    // Windows
-    { platform: 'windows', arch: 'arm64', avx2: false },
-    { platform: 'windows', arch: 'x64', avx2: true },
-    { platform: 'windows', arch: 'x64', avx2: false },
-  ]
-
-  for (const c of cases) {
-    const label = `${c.platform}/${c.arch} avx2=${c.avx2}${c.musl !== undefined ? ` musl=${c.musl}` : ''}`
-    test(label, () => {
-      const fromPostinstall = buildCandidates(c.platform, c.arch, { avx2: c.avx2, musl: c.musl })
-      const fromLauncher = launcherCandidates(c.platform, c.arch, { avx2: c.avx2, musl: c.musl })
-      expect(fromPostinstall).toEqual(fromLauncher)
-    })
-  }
-})
-
-// ---------------------------------------------------------------------------
-// Silent failure
-// ---------------------------------------------------------------------------
-
-describe('postinstall — silent failure', () => {
-  test('exits 0 when no platform packages are installed', async () => {
-    const proc = Bun.spawn(['node', resolve(import.meta.dir, '..', '..', 'scripts', 'postinstall.mjs')], {
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
-    const exitCode = await proc.exited
-    expect(exitCode).toBe(0)
-  })
-})

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)
-  })
-})

package/src/commands/build.ts

@@ -1,58 +0,0 @@
-import { render } from 'ink'
-import { createElement } from 'react'
-import type { Command } from '../commands.ts'
-import { BuildView } from '../tui/views/build/build-view.tsx'
-import { resolveTargetDir } from './resolve-dir.ts'
-
-export const buildCommand: Command = {
-  name: 'build',
-  description: 'Build a facet from the current directory',
-  usage: '[directory]',
-  run: async (args: string[], _flags: Record<string, unknown>): Promise<number> => {
-    const resolved = await resolveTargetDir(args[0], { mustExist: true, facetMustExist: true })
-    if (!resolved.ok) {
-      console.error(resolved.message)
-      return 1
-    }
-
-    const rootDir = resolved.dir
-    const displayDir = resolved.display
-
-    // Track result for stdout summary after Ink exits
-    let buildName = ''
-    let buildVersion = ''
-    let artifactCount = 0
-    let integrity = ''
-    let errorCount = 0
-
-    const instance = render(
-      createElement(BuildView, {
-        rootDir,
-        onSuccess: (name: string, version: string, fileCount: number, hash: string) => {
-          buildName = name
-          buildVersion = version
-          artifactCount = fileCount
-          integrity = hash
-        },
-        onFailure: (count: number) => {
-          errorCount = count
-        },
-      }),
-    )
-
-    try {
-      await instance.waitUntilExit()
-      // Ink has unmounted — print stdout summary for scroll-back
-      const shortHash = integrity.length > 20 ? `${integrity.slice(0, 20)}...` : integrity
-      process.stdout.write(
-        `✓ Built ${buildName} v${buildVersion} → ${displayDir}/dist/ (${artifactCount} assets, ${shortHash})\n`,
-      )
-      return 0
-    } catch {
-      process.stdout.write(
-        `✗ Build failed — ${errorCount} error${errorCount !== 1 ? 's' : ''}. Run \`facet edit${args[0] ? ` ${displayDir}` : ''}\` to fix.\n`,
-      )
-      return 1
-    }
-  },
-}