agent-facets 0.3.0 → 0.3.5

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

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

@@ -1,191 +0,0 @@
-import { Box, Text } from 'ink'
-import { useState } from 'react'
-import { useFocusMode } from '../context/focus-mode-context.ts'
-import { useFocusOrder } from '../context/focus-order-context.ts'
-import type { AssetSectionKey } from '../context/form-state-context.ts'
-import { useFormState } from '../context/form-state-context.ts'
-import { AssetDescription, truncateDescription } from './asset-description.tsx'
-import type { AssetField } from './asset-field-picker.tsx'
-import { AssetFieldPicker } from './asset-field-picker.tsx'
-import { AssetInlineInput } from './asset-inline-input.tsx'
-import { AssetItem } from './asset-item.tsx'
-import { Button } from './button.tsx'
-
-export function AssetSection({
-  section,
-  label,
-  defaultName,
-  dimmed,
-  validate,
-  onEditDescription,
-}: {
-  section: AssetSectionKey
-  label: string
-  defaultName?: string
-  dimmed?: boolean
-  validate?: (value: string) => string | undefined
-  onEditDescription?: (section: AssetSectionKey, name: string) => void
-}) {
-  const { form, addAsset, removeAsset, renameAsset, setAssetAdding, setAssetEditing } = useFormState()
-  const { items, descriptions, editing, adding } = form.assets[section]
-  const { setMode } = useFocusMode()
-  const { focusedId, focus } = useFocusOrder()
-  const [inputValue, setInputValue] = useState('')
-  const [error, setError] = useState('')
-  const [selectedItem, setSelectedItem] = useState<string | null>(null)
-
-  const startAdding = () => {
-    setAssetAdding(section, true)
-    setInputValue('')
-    setError('')
-    setMode('field-revision')
-  }
-
-  const startEditing = (name: string) => {
-    setAssetEditing(section, name)
-    setInputValue(name)
-    setError('')
-    setMode('field-revision')
-  }
-
-  const closeInput = (focusTarget?: string | false) => {
-    setAssetAdding(section, false)
-    setAssetEditing(section, undefined)
-    setInputValue('')
-    setError('')
-    if (focusTarget !== false) {
-      setMode('form-navigation')
-      focus(focusTarget ?? `add-${section}`)
-    }
-  }
-
-  const handleFieldChoice = (name: string, field: AssetField) => {
-    setSelectedItem(null)
-    if (field === 'name') {
-      startEditing(name)
-    } else {
-      onEditDescription?.(section, name)
-    }
-  }
-
-  const handleRemove = (name: string) => {
-    const index = items.indexOf(name)
-    removeAsset(section, name)
-
-    if (index < items.length - 1) {
-      focus(`item-${section}-${index}`)
-    } else if (index > 0) {
-      focus(`item-${section}-${index - 1}`)
-    } else {
-      focus(`add-${section}`)
-    }
-  }
-
-  return (
-    <Box flexDirection="column" gap={0}>
-      <Box gap={1}>
-        <Text bold dimColor={dimmed}>
-          {label}
-        </Text>
-        {items.length === 0 && !adding && <Text dimColor>(none)</Text>}
-      </Box>
-
-      {items.map((item, i) => {
-        const itemId = `item-${section}-${i}`
-        const isFocusedItem = focusedId === itemId
-        const description = descriptions[item] ?? `A ${item} ${section}`
-
-        // Field picker (entered via ↓ during name editing)
-        if (selectedItem === item) {
-          return (
-            <AssetFieldPicker
-              key={itemId}
-              name={item}
-              description={truncateDescription(description)}
-              initialField="description"
-              onChoose={(field) => handleFieldChoice(item, field)}
-              onCancel={() => {
-                setSelectedItem(null)
-                setMode('form-navigation')
-                focus(itemId)
-              }}
-            />
-          )
-        }
-
-        // Inline name editing
-        if (editing === item) {
-          return (
-            <Box key={itemId} flexDirection="column">
-              <AssetInlineInput
-                id={itemId}
-                value={inputValue}
-                placeholder={item}
-                error={error}
-                isFocused={isFocusedItem}
-                onChange={setInputValue}
-                validate={validate}
-                onError={setError}
-                onSubmit={(newName) => {
-                  renameAsset(section, item, newName)
-                  closeInput(itemId)
-                }}
-                onCancel={() => closeInput(itemId)}
-                onDownArrow={() => {
-                  closeInput(false)
-                  setSelectedItem(item)
-                }}
-              />
-              <AssetDescription description={description} />
-            </Box>
-          )
-        }
-
-        // Normal display (level 1)
-        return (
-          <Box key={itemId} flexDirection="column">
-            <AssetItem
-              id={itemId}
-              name={item}
-              isFocused={isFocusedItem}
-              onEdit={() => startEditing(item)}
-              onRemove={() => handleRemove(item)}
-            />
-            <AssetDescription description={description} />
-          </Box>
-        )
-      })}
-
-      {adding ? (
-        <AssetInlineInput
-          id={`add-${section}`}
-          value={inputValue}
-          placeholder={defaultName}
-          error={error}
-          isFocused={focusedId === `add-${section}`}
-          onChange={setInputValue}
-          validate={validate}
-          onError={setError}
-          onSubmit={(name) => {
-            addAsset(section, name)
-            closeInput()
-          }}
-          onCancel={closeInput}
-        />
-      ) : (
-        <Box marginLeft={2}>
-          <Button
-            id={`add-${section}`}
-            label="+ Add"
-            hint={
-              <Text dimColor>
-                <Text>Enter</Text> to add
-              </Text>
-            }
-            onPress={startAdding}
-          />
-        </Box>
-      )}
-    </Box>
-  )
-}

package/src/tui/components/button.tsx

@@ -1,92 +0,0 @@
-import { Box, Text, useInput } from 'ink'
-import Gradient from 'ink-gradient'
-import type { ReactNode } from 'react'
-import { useEffect, useState } from 'react'
-import { useFocusOrder } from '../context/focus-order-context.ts'
-import { GRADIENT_STOPS, getAnimatedGradient } from '../gradient.ts'
-import { THEME } from '../theme.ts'
-
-const ANIMATION_INTERVAL_MS = 75
-
-export function Button({
-  id,
-  label,
-  hint,
-  onPress,
-  disabled,
-  color,
-  gradient: showGradient,
-  animateGradient,
-}: {
-  id: string
-  label: string
-  hint?: ReactNode
-  onPress: () => void
-  disabled?: boolean
-  color?: string
-  autoFocus?: boolean
-  gradient?: boolean
-  animateGradient?: boolean
-}) {
-  const { focusedId } = useFocusOrder()
-  const isFocused = focusedId === id && !disabled
-  const [offset, setOffset] = useState(0)
-
-  useEffect(() => {
-    if (!animateGradient) return
-    const interval = setInterval(() => {
-      setOffset((prev) => (prev + 1) % GRADIENT_STOPS.length)
-    }, ANIMATION_INTERVAL_MS)
-    return () => clearInterval(interval)
-  }, [animateGradient])
-
-  useInput(
-    (_input, key) => {
-      if (key.return) {
-        onPress()
-      }
-    },
-    { isActive: isFocused },
-  )
-
-  const prefix = isFocused ? '▸ ' : '  '
-
-  const focusHint = isFocused && hint ? <Text> {hint}</Text> : null
-
-  if (disabled) {
-    return (
-      <Box gap={0}>
-        <Text color="gray" dimColor>
-          {prefix}
-          {label}
-        </Text>
-      </Box>
-    )
-  }
-
-  if (showGradient) {
-    const colors = animateGradient ? getAnimatedGradient(offset) : [...THEME.gradient]
-
-    return (
-      <Box gap={0}>
-        <Gradient colors={colors}>
-          <Text bold>
-            {prefix}
-            {label}
-          </Text>
-        </Gradient>
-        {focusHint}
-      </Box>
-    )
-  }
-
-  return (
-    <Box gap={0}>
-      <Text color={isFocused ? (color ?? THEME.primary) : undefined} bold={isFocused}>
-        {prefix}
-        {label}
-      </Text>
-      {focusHint}
-    </Box>
-  )
-}