agent-facets 0.2.2 → 0.3.3

package/src/commands/resolve-dir.ts

@@ -1,98 +0,0 @@
-import { mkdir, stat } from 'node:fs/promises'
-import { dirname, join, resolve } from 'node:path'
-import { FACET_MANIFEST_FILE } from '@agent-facets/core'
-
-export interface ResolvedDir {
-  ok: true
-  dir: string
-  display: string
-}
-
-export interface ResolvedDirError {
-  ok: false
-  message: string
-}
-
-export type ResolveResult = ResolvedDir | ResolvedDirError
-
-export interface ResolveOptions {
-  mustExist: boolean
-  facetMustExist?: boolean
-}
-
-/**
- * Validates and resolves a directory argument for CLI commands.
- *
- * Handles:
- * - No argument → uses process.cwd(), display as '.'
- * - Argument ending with facet.json → silently uses parent directory
- * - Argument is a non-directory file → error
- * - Directory doesn't exist + mustExist false → auto-creates it
- * - Directory doesn't exist + mustExist true → error
- * - facetMustExist true but no facet.json → error
- */
-export async function resolveTargetDir(arg: string | undefined, opts: ResolveOptions): Promise<ResolveResult> {
-  const display = arg || '.'
-
-  // No argument → current directory
-  if (!arg) {
-    const dir = process.cwd()
-
-    if (opts.facetMustExist) {
-      const manifestExists = await Bun.file(join(dir, FACET_MANIFEST_FILE)).exists()
-      if (!manifestExists) {
-        return { ok: false, message: `No ${FACET_MANIFEST_FILE} found in ${display}` }
-      }
-    }
-
-    return { ok: true, dir, display }
-  }
-
-  // Pointing to facet.json directly → use parent directory
-  if (arg === FACET_MANIFEST_FILE || arg.endsWith(`/${FACET_MANIFEST_FILE}`)) {
-    const dir = resolve(dirname(arg))
-
-    const dirStat = await stat(dir).catch(() => null)
-    if (!dirStat?.isDirectory()) {
-      return { ok: false, message: `Directory does not exist: ${dirname(arg)}` }
-    }
-
-    if (opts.facetMustExist) {
-      const manifestExists = await Bun.file(join(dir, FACET_MANIFEST_FILE)).exists()
-      if (!manifestExists) {
-        return { ok: false, message: `No ${FACET_MANIFEST_FILE} found in ${display}` }
-      }
-    }
-
-    return { ok: true, dir, display: dirname(arg) || '.' }
-  }
-
-  // Check if the path exists
-  const pathStat = await stat(arg).catch(() => null)
-
-  // Path exists but is a file, not a directory
-  if (pathStat && !pathStat.isDirectory()) {
-    return { ok: false, message: `Expected a directory, not a file: ${arg}` }
-  }
-
-  // Path doesn't exist
-  if (!pathStat) {
-    if (opts.mustExist) {
-      return { ok: false, message: `Directory does not exist: ${arg}` }
-    }
-
-    // Auto-create for commands that allow it (e.g., create)
-    await mkdir(arg, { recursive: true })
-  }
-
-  const dir = resolve(arg)
-
-  if (opts.facetMustExist) {
-    const manifestExists = await Bun.file(join(dir, FACET_MANIFEST_FILE)).exists()
-    if (!manifestExists) {
-      return { ok: false, message: `No ${FACET_MANIFEST_FILE} found in ${display}` }
-    }
-  }
-
-  return { ok: true, dir, display }
-}

package/src/commands.ts

@@ -1,40 +0,0 @@
-import { buildCommand } from './commands/build.ts'
-import { createCommand } from './commands/create/index.ts'
-import { editCommand } from './commands/edit/index.ts'
-
-export type FlagDef = {
-  type: 'boolean' | 'string'
-  description: string
-}
-
-export type Command = {
-  name: string
-  description: string
-  usage?: string
-  flags?: Record<string, FlagDef>
-  run: (args: string[], flags: Record<string, unknown>) => Promise<number>
-}
-
-function stubCommand(name: string, description: string): Command {
-  return {
-    name,
-    description,
-    run: async (_args, _flags) => {
-      console.log(`"${name}" is not yet implemented.`)
-      return 0
-    },
-  }
-}
-
-export const commands: Record<string, Command> = {
-  add: stubCommand('add', 'Add a facet to the project'),
-  build: buildCommand,
-  create: createCommand,
-  edit: editCommand,
-  info: stubCommand('info', 'Show information about a facet'),
-  install: stubCommand('install', 'Install all facets from the lockfile'),
-  list: stubCommand('list', 'List installed facets'),
-  publish: stubCommand('publish', 'Publish a facet to the registry'),
-  remove: stubCommand('remove', 'Remove a facet from the project'),
-  upgrade: stubCommand('upgrade', 'Upgrade installed facets'),
-}

package/src/help.ts

@@ -1,43 +0,0 @@
-import type { Command } from './commands.ts'
-import { version } from './version.ts'
-
-export function printGlobalHelp(commands: Record<string, Command>): void {
-  const entries = Object.values(commands)
-  const maxNameLength = Math.max(...entries.map((c) => c.name.length))
-
-  const lines = [
-    `facet v${version}`,
-    '',
-    'Usage: facet <command> [options]',
-    '',
-    'Commands:',
-    ...entries.map((c) => `  ${c.name.padEnd(maxNameLength + 2)}${c.description}`),
-    '',
-    'Options:',
-    '  --help       Show help',
-    '  --version    Show version',
-  ]
-
-  console.log(lines.join('\n'))
-}
-
-export function printCommandHelp(command: Command): void {
-  const usage = command.usage ? ` ${command.usage}` : ''
-
-  const lines = [`Usage: facet ${command.name}${usage} [options]`, '', `  ${command.description}`, '', 'Options:']
-
-  if (command.flags) {
-    const flagEntries = Object.entries(command.flags)
-    const maxFlagLength = Math.max(...flagEntries.map(([name]) => `--${name}`.length), '--help'.length)
-
-    for (const [name, def] of flagEntries) {
-      lines.push(`  ${`--${name}`.padEnd(maxFlagLength + 4)}${def.description}`)
-    }
-
-    lines.push(`  ${'--help'.padEnd(maxFlagLength + 4)}Show help`)
-  } else {
-    lines.push('  --help    Show help')
-  }
-
-  console.log(lines.join('\n'))
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-import { commands } from './commands.ts'
-import { run } from './run.ts'
-
-try {
-  const code = await run(process.argv.slice(2), commands)
-  process.exit(code)
-} catch (error) {
-  console.error(error instanceof Error ? error.message : 'An unexpected error occurred.')
-  process.exit(2)
-}

package/src/run.ts

@@ -1,82 +0,0 @@
-import { parse } from '@bomb.sh/args'
-import type { Command } from './commands.ts'
-import { printCommandHelp, printGlobalHelp } from './help.ts'
-import { findClosestCommand } from './suggest.ts'
-import { version } from './version.ts'
-
-export async function run(argv: string[], commands: Record<string, Command>): Promise<number> {
-  const args = parse(argv, {
-    boolean: ['help', 'version'],
-  })
-
-  if (args.version) {
-    console.log(version)
-    return 0
-  }
-
-  const commandName = String(args._[0] ?? '')
-
-  // No command given — show global help
-  if (!commandName) {
-    printGlobalHelp(commands)
-    return 0
-  }
-
-  // Explicit `help` command: `facets help` or `facets help build`
-  if (commandName === 'help') {
-    const subCommandName = String(args._[1] ?? '')
-    const subCommand = subCommandName ? commands[subCommandName] : undefined
-    if (subCommand) {
-      printCommandHelp(subCommand)
-    } else {
-      printGlobalHelp(commands)
-    }
-    return 0
-  }
-
-  const command = commands[commandName]
-
-  if (!command) {
-    const suggestion = findClosestCommand(commandName, Object.keys(commands))
-    const message = suggestion
-      ? `Unknown command "${commandName}". Did you mean "${suggestion}"?`
-      : `Unknown command "${commandName}".`
-    console.error(message)
-    return 1
-  }
-
-  // Per-command help: `facets build --help`
-  if (args.help) {
-    printCommandHelp(command)
-    return 0
-  }
-
-  // Build per-command flag parsing config
-  const booleanFlags: string[] = []
-  const stringFlags: string[] = []
-
-  if (command.flags) {
-    for (const [name, def] of Object.entries(command.flags)) {
-      if (def.type === 'boolean') booleanFlags.push(name)
-      else if (def.type === 'string') stringFlags.push(name)
-    }
-  }
-
-  // Parse with per-command config
-  const parsed = parse(argv.slice(1), {
-    boolean: booleanFlags,
-    string: stringFlags,
-  })
-
-  // Build positional args and flags
-  const positionalArgs = parsed._.map(String)
-  const flags: Record<string, unknown> = {}
-
-  for (const name of [...booleanFlags, ...stringFlags]) {
-    if (parsed[name] !== undefined) {
-      flags[name] = parsed[name]
-    }
-  }
-
-  return command.run(positionalArgs, flags)
-}

package/src/suggest.ts

@@ -1,35 +0,0 @@
-function levenshtein(a: string, b: string): number {
-  const m = a.length
-  const n = b.length
-  const row: number[] = []
-
-  for (let j = 0; j <= n; j++) row.push(j)
-
-  for (let i = 1; i <= m; i++) {
-    let prev = row[0] ?? 0
-    row[0] = i
-    for (let j = 1; j <= n; j++) {
-      const current = row[j] ?? 0
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1
-      row[j] = Math.min(current + 1, (row[j - 1] ?? 0) + 1, prev + cost)
-      prev = current
-    }
-  }
-
-  return row[n] ?? 0
-}
-
-export function findClosestCommand(input: string, commandNames: string[]): string | undefined {
-  let best: string | undefined
-  let bestDistance = Infinity
-
-  for (const name of commandNames) {
-    const distance = levenshtein(input, name)
-    if (distance < bestDistance) {
-      bestDistance = distance
-      best = name
-    }
-  }
-
-  return bestDistance <= 3 ? best : undefined
-}

package/src/tui/components/asset-description.tsx

@@ -1,17 +0,0 @@
-import { Box, Text } from 'ink'
-
-export function truncateDescription(text: string, maxLen = 50): string {
-  const lines = text.split(/\r?\n/)
-  const firstLine = lines[0] ?? text
-  const hasMore = lines.length > 1
-  if (firstLine.length <= maxLen) return hasMore ? `${firstLine}...` : firstLine
-  return `${firstLine.slice(0, maxLen)}...`
-}
-
-export function AssetDescription({ description }: { description: string }) {
-  return (
-    <Box marginLeft={4}>
-      <Text dimColor>{truncateDescription(description)}</Text>
-    </Box>
-  )
-}

package/src/tui/components/asset-field-picker.tsx

@@ -1,78 +0,0 @@
-import { Box, Text, useInput } from 'ink'
-import { useEffect, useState } from 'react'
-import { useFocusMode } from '../context/focus-mode-context.ts'
-import { THEME } from '../theme.ts'
-
-export type AssetField = 'name' | 'description'
-
-export function AssetFieldPicker({
-  name,
-  description,
-  initialField,
-  onChoose,
-  onCancel,
-}: {
-  name: string
-  description: string
-  initialField?: AssetField
-  onChoose: (field: AssetField) => void
-  onCancel: () => void
-}) {
-  const { setMode } = useFocusMode()
-  const [field, setField] = useState<AssetField>(initialField ?? 'name')
-
-  useEffect(() => {
-    setMode('field-revision')
-    return () => setMode('form-navigation')
-  }, [setMode])
-
-  useInput((_input, key) => {
-    if (key.upArrow) setField('name')
-    if (key.downArrow) setField('description')
-    if (key.escape) onCancel()
-    if (key.return) onChoose(field)
-  })
-
-  return (
-    <Box flexDirection="column">
-      <Box gap={1} marginLeft={2}>
-        {field === 'name' ? (
-          <>
-            <Text color={THEME.primary} bold>
-              ▸
-            </Text>
-            <Text color={THEME.primary}>{name}</Text>
-            <Text color={THEME.hint}>
-              <Text color={THEME.keyword}>↑↓</Text> select · <Text color={THEME.keyword}>Enter</Text> edit ·{' '}
-              <Text color={THEME.keyword}>Esc</Text> back
-            </Text>
-          </>
-        ) : (
-          <>
-            <Text color={THEME.success}>•</Text>
-            <Text>{name}</Text>
-          </>
-        )}
-      </Box>
-      <Box gap={1} marginLeft={2}>
-        {field === 'description' ? (
-          <>
-            <Text color={THEME.primary} bold>
-              ▸
-            </Text>
-            <Text color={THEME.primary}>{description}</Text>
-            <Text color={THEME.hint}>
-              <Text color={THEME.keyword}>↑↓</Text> select · <Text color={THEME.keyword}>Enter</Text> edit ·{' '}
-              <Text color={THEME.keyword}>Esc</Text> back
-            </Text>
-          </>
-        ) : (
-          <>
-            <Text> </Text>
-            <Text dimColor>{description}</Text>
-          </>
-        )}
-      </Box>
-    </Box>
-  )
-}

package/src/tui/components/asset-inline-input.tsx

@@ -1,91 +0,0 @@
-import { Box, Text, useInput } from 'ink'
-import TextInput from 'ink-text-input'
-import { THEME } from '../theme.ts'
-
-export function AssetInlineInput({
-  value,
-  placeholder,
-  error,
-  isFocused,
-  onChange,
-  validate,
-  onError,
-  onSubmit,
-  onCancel,
-  onDownArrow,
-}: {
-  id: string
-  value: string
-  placeholder?: string
-  error: string
-  isFocused: boolean
-  onChange: (value: string) => void
-  validate?: (value: string) => string | undefined
-  onError: (error: string) => void
-  onSubmit: (name: string) => void
-  onCancel: () => void
-  onDownArrow?: () => void
-}) {
-  useInput(
-    (_input, key) => {
-      if (!isFocused) return
-      if (key.return) {
-        const name = value || placeholder || ''
-        if (!name) {
-          onCancel()
-          return
-        }
-        if (validate) {
-          const err = validate(name)
-          if (err) {
-            onError(err)
-            return
-          }
-        }
-        onSubmit(name)
-        return
-      }
-      if (key.escape) {
-        onCancel()
-        return
-      }
-      if (key.downArrow && onDownArrow) {
-        onDownArrow()
-        return
-      }
-      if (key.tab && !value && placeholder) {
-        onChange(placeholder)
-        return
-      }
-    },
-    { isActive: isFocused },
-  )
-
-  return (
-    <Box marginLeft={2} gap={1}>
-      <Text color={THEME.tertiary}>{'>'}</Text>
-      <TextInput value={value} onChange={onChange} placeholder={placeholder} focus={isFocused} />
-      {error ? (
-        <Text color={THEME.warning}>· {error}</Text>
-      ) : value ? (
-        <Text color={THEME.hint}>
-          · <Text color={THEME.keyword}>Enter</Text> save ·{' '}
-          {onDownArrow && (
-            <>
-              <Text color={THEME.keyword}>↓</Text> description ·{' '}
-            </>
-          )}
-          <Text color={THEME.keyword}>Esc</Text> revert
-        </Text>
-      ) : placeholder ? (
-        <Text color={THEME.hint}>
-          · <Text color={THEME.keyword}>Tab</Text> to fill · <Text color={THEME.keyword}>Escape</Text> to cancel
-        </Text>
-      ) : (
-        <Text color={THEME.hint}>
-          · <Text color={THEME.keyword}>Enter</Text> to add · <Text color={THEME.keyword}>Escape</Text> to cancel
-        </Text>
-      )}
-    </Box>
-  )
-}

package/src/tui/components/asset-item.tsx

@@ -1,44 +0,0 @@
-import { Box, Text, useInput } from 'ink'
-import { THEME } from '../theme.ts'
-
-export function AssetItem({
-  name,
-  isFocused,
-  onEdit,
-  onRemove,
-}: {
-  id: string
-  name: string
-  isFocused: boolean
-  onEdit: () => void
-  onRemove: () => void
-}) {
-  useInput(
-    (_input, key) => {
-      if (key.return) onEdit()
-      if (key.delete || key.backspace) onRemove()
-    },
-    { isActive: isFocused },
-  )
-
-  return (
-    <Box gap={1} marginLeft={2}>
-      {isFocused ? (
-        <>
-          <Text color={THEME.primary} bold>
-            ▸
-          </Text>
-          <Text color={THEME.primary}>{name}</Text>
-          <Text color={THEME.hint}>
-            <Text color={THEME.keyword}>Enter</Text> edit name · <Text color={THEME.keyword}>Del</Text> remove
-          </Text>
-        </>
-      ) : (
-        <>
-          <Text color={THEME.success}>•</Text>
-          <Text>{name}</Text>
-        </>
-      )}
-    </Box>
-  )
-}