agent-facets 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,30 @@
+# agent-facets
+
+## 0.1.1
+
+### Patch Changes
+
+- 5813b90: Small test for change set management in CI
+- Updated dependencies [5813b90]
+  - @agent-facets/core@0.1.1
+
+## 0.1.0
+
+### Minor Changes
+
+- 2243bbf: Added basic create command to CLI
+
+### Patch Changes
+
+- Updated dependencies [2243bbf]
+  - @agent-facets/core@0.1.0
+
+## 0.0.1
+
+### Patch Changes
+
+- 74e3d25: Should be 0.0.1 now
+- 74e3d25: Initial publishing
+- Updated dependencies [74e3d25]
+- Updated dependencies [74e3d25]
+  - @agent-facets/core@0.0.1

package/bunfig.toml

@@ -0,0 +1,2 @@
+[test.reporter]
+junit = "../../test-results/cli-junit.xml"

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "agent-facets",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agent-facets/facets",
+    "directory": "packages/cli"
+  },
+  "version": "0.1.1",
+  "type": "module",
+  "bin": {
+    "facet": "./dist/facet"
+  },
+  "scripts": {
+    "build": "bun build src/index.ts --compile --outfile dist/facet",
+    "types": "tsc --noEmit",
+    "test": "bun test --timeout 15000"
+  },
+  "dependencies": {
+    "@agent-facets/brand": "workspace:*",
+    "@bomb.sh/args": "0.3.1",
+    "@agent-facets/core": "workspace:*",
+    "@types/react": "19.2.14",
+    "ink": "6.8.0",
+    "ink-gradient": "4.0.0",
+    "ink-spinner": "5.0.0",
+    "ink-text-input": "6.0.0",
+    "react": "19.2.4",
+    "react-devtools-core": "7.0.1"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.10",
+    "ink-testing-library": "4.0.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
+  }
+}

package/src/__tests__/cli.test.ts

@@ -0,0 +1,152 @@
+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', '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('')
+  })
+})
+
+// --- 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 exits with code 2', async () => {
+    // This test runs against source (not compiled binary) because it needs to
+    // monkey-patch the command registry to inject a crashing command.
+    const script = `
+      import { commands } from '${resolve(import.meta.dir, '../commands.ts')}'
+      import { run } from '${resolve(import.meta.dir, '../run.ts')}'
+      commands['crash'] = {
+        name: 'crash',
+        description: 'Throws an error',
+        run: async () => { throw new Error('boom') },
+      }
+      try {
+        const code = await run(['crash'])
+        process.exit(code)
+      } catch (error) {
+        console.error(error instanceof Error ? error.message : 'An unexpected error occurred.')
+        process.exit(2)
+      }
+    `
+    const proc = Bun.spawn(['bun', '--eval', script], {
+      stdout: 'pipe',
+      stderr: 'pipe',
+    })
+    const stderr = await new Response(proc.stderr).text()
+    const exitCode = await proc.exited
+    expect(exitCode).toBe(2)
+    expect(stderr.trim()).toContain('boom')
+  })
+})

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

@@ -0,0 +1,207 @@
+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'
+
+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: '0.1.0',
+        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.md')
+    expect(files).toContain('skills/testing-guide.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('0.1.0')
+    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.md')).text()
+    expect(skill).toContain('# Code Review')
+
+    const skill2 = await Bun.file(join(dir, 'skills/testing-guide.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: '0.1.0',
+        description: '',
+        skills: ['minimal'],
+        agents: [],
+        commands: [],
+      },
+      dir,
+    )
+
+    expect(files).toContain('facet.json')
+    expect(files).toContain('skills/minimal.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('scaffolded project passes build', async () => {
+    const dir = await createFixtureDir('scaffold-buildable')
+    await writeScaffold(
+      {
+        name: 'buildable',
+        version: '0.1.0',
+        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-0.1.0.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.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.stdout).toContain('Build failed')
+  })
+
+  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/commands/build.ts

@@ -0,0 +1,45 @@
+import { render } from 'ink'
+import { createElement } from 'react'
+import type { Command } from '../commands.ts'
+import { BuildView } from '../tui/views/build/build-view.tsx'
+
+export const buildCommand: Command = {
+  name: 'build',
+  description: 'Build a facet from the current directory',
+  run: async (args: string[]): Promise<number> => {
+    const rootDir = args[0] || process.cwd()
+
+    // 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} → dist/ (${artifactCount} assets, ${shortHash})\n`)
+      return 0
+    } catch {
+      process.stdout.write(`✗ Build failed — ${errorCount} error${errorCount !== 1 ? 's' : ''}\n`)
+      return 1
+    }
+  },
+}

package/src/commands/create/index.ts

@@ -0,0 +1,30 @@
+import type { Command } from '../../commands.ts'
+import { writeScaffold } from '../create-scaffold.ts'
+import { runCreateWizardInk } from './wizard.tsx'
+
+export type { CreateOptions } from '../create-scaffold.ts'
+export { writeScaffold } from '../create-scaffold.ts'
+
+export const createCommand: Command = {
+  name: 'create',
+  description: 'Create a new facet project interactively',
+  run: async (args: string[]): Promise<number> => {
+    const targetDir = args[0] || process.cwd()
+
+    const opts = await runCreateWizardInk()
+    if (!opts) {
+      console.log('\nCancelled.')
+      return 1
+    }
+
+    const files = await writeScaffold(opts, targetDir)
+
+    console.log(`\nFacet created: ${opts.name}`)
+    for (const file of files) {
+      console.log(`  ${file}`)
+    }
+    console.log('\nRun "facet build" to validate your facet.')
+
+    return 0
+  },
+}

package/src/commands/create/types.ts

@@ -0,0 +1,9 @@
+export type AssetType = 'skill' | 'agent' | 'command'
+
+export const ASSET_TYPES: AssetType[] = ['skill', 'command', 'agent']
+
+export const ASSET_LABELS: Record<AssetType, string> = {
+  skill: 'Skills',
+  agent: 'Agents',
+  command: 'Commands',
+}

package/src/commands/create/wizard.tsx

@@ -0,0 +1,24 @@
+import { render } from 'ink'
+import { CreateWizard } from '../../tui/views/create/wizard.tsx'
+import type { CreateOptions } from '../create-scaffold.ts'
+
+export async function runCreateWizardInk(): Promise<CreateOptions | null> {
+  return new Promise<CreateOptions | null>((resolve) => {
+    let result: CreateOptions | null = null
+
+    const instance = render(
+      <CreateWizard
+        onComplete={(opts) => {
+          result = opts
+        }}
+        onCancel={() => {
+          result = null
+        }}
+      />,
+    )
+
+    instance.waitUntilExit().then(() => {
+      resolve(result)
+    })
+  })
+}