feat: Add bd formula list/show commands (gt-8tmz.14)
Implements formula management commands: - bd formula list: Lists formulas from all search paths - bd formula show <name>: Shows formula details, steps, composition rules Search paths in priority order: 1. .beads/formulas/ (project) 2. ~/.beads/formulas/ (user) 3. ~/gt/.beads/formulas/ (town) Features: - Type filtering (--type workflow|expansion|aspect) - JSON output support (--json) - Shows variables, steps, advice, bond points, and aspects - Formulas in earlier paths shadow later ones 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Steve Yegge
480
cmd/bd/formula.go
Normal file
480
cmd/bd/formula.go
Normal file
@@ -0,0 +1,480 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
"github.com/steveyegge/beads/internal/formula"
|
||||
"github.com/steveyegge/beads/internal/ui"
|
||||
)
|
||||
|
||||
// formulaCmd is the parent command for formula operations.
|
||||
var formulaCmd = &cobra.Command{
|
||||
Use: "formula",
|
||||
Short: "Manage workflow formulas",
|
||||
Long: `Manage workflow formulas - the source layer for molecule templates.
|
||||
|
||||
Formulas are YAML/JSON files that define workflows with composition rules.
|
||||
They are "cooked" into proto beads which can then be poured or wisped.
|
||||
|
||||
The Rig → Cook → Run lifecycle:
|
||||
- Rig: Compose formulas (extends, compose)
|
||||
- Cook: Transform to proto (bd cook expands macros, applies aspects)
|
||||
- Run: Agents execute poured mols or wisps
|
||||
|
||||
Search paths (in order):
|
||||
1. .beads/formulas/ (project)
|
||||
2. ~/.beads/formulas/ (user)
|
||||
3. ~/gt/.beads/formulas/ (town)
|
||||
|
||||
Commands:
|
||||
list List available formulas from all search paths
|
||||
show Show formula details, steps, and composition rules`,
|
||||
}
|
||||
|
||||
// formulaListCmd lists all available formulas.
|
||||
var formulaListCmd = &cobra.Command{
|
||||
Use: "list",
|
||||
Short: "List available formulas",
|
||||
Long: `List all formulas from search paths.
|
||||
|
||||
Search paths (in order of priority):
|
||||
1. .beads/formulas/ (project - highest priority)
|
||||
2. ~/.beads/formulas/ (user)
|
||||
3. ~/gt/.beads/formulas/ (town)
|
||||
|
||||
Formulas in earlier paths shadow those with the same name in later paths.
|
||||
|
||||
Examples:
|
||||
bd formula list
|
||||
bd formula list --json
|
||||
bd formula list --type workflow
|
||||
bd formula list --type aspect`,
|
||||
Run: runFormulaList,
|
||||
}
|
||||
|
||||
// formulaShowCmd shows details of a specific formula.
|
||||
var formulaShowCmd = &cobra.Command{
|
||||
Use: "show <formula-name>",
|
||||
Short: "Show formula details",
|
||||
Long: `Show detailed information about a formula.
|
||||
|
||||
Displays:
|
||||
- Formula metadata (name, type, description)
|
||||
- Variables with defaults and constraints
|
||||
- Steps with dependencies
|
||||
- Composition rules (extends, aspects, expansions)
|
||||
- Bond points for external composition
|
||||
|
||||
Examples:
|
||||
bd formula show shiny
|
||||
bd formula show rule-of-five
|
||||
bd formula show security-audit --json`,
|
||||
Args: cobra.ExactArgs(1),
|
||||
Run: runFormulaShow,
|
||||
}
|
||||
|
||||
// FormulaListEntry represents a formula in the list output.
|
||||
type FormulaListEntry struct {
|
||||
Name string `json:"name"`
|
||||
Type string `json:"type"`
|
||||
Description string `json:"description"`
|
||||
Source string `json:"source"`
|
||||
Steps int `json:"steps"`
|
||||
Vars int `json:"vars"`
|
||||
}
|
||||
|
||||
func runFormulaList(cmd *cobra.Command, args []string) {
|
||||
typeFilter, _ := cmd.Flags().GetString("type")
|
||||
|
||||
// Get all search paths
|
||||
searchPaths := getFormulaSearchPaths()
|
||||
|
||||
// Track seen formulas (first occurrence wins)
|
||||
seen := make(map[string]bool)
|
||||
var entries []FormulaListEntry
|
||||
|
||||
// Scan each search path
|
||||
for _, dir := range searchPaths {
|
||||
formulas, err := scanFormulaDir(dir)
|
||||
if err != nil {
|
||||
continue // Skip inaccessible directories
|
||||
}
|
||||
|
||||
for _, f := range formulas {
|
||||
if seen[f.Formula] {
|
||||
continue // Skip shadowed formulas
|
||||
}
|
||||
seen[f.Formula] = true
|
||||
|
||||
// Apply type filter
|
||||
if typeFilter != "" && string(f.Type) != typeFilter {
|
||||
continue
|
||||
}
|
||||
|
||||
entries = append(entries, FormulaListEntry{
|
||||
Name: f.Formula,
|
||||
Type: string(f.Type),
|
||||
Description: truncateDescription(f.Description, 60),
|
||||
Source: f.Source,
|
||||
Steps: countSteps(f.Steps),
|
||||
Vars: len(f.Vars),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Sort by name
|
||||
sort.Slice(entries, func(i, j int) bool {
|
||||
return entries[i].Name < entries[j].Name
|
||||
})
|
||||
|
||||
if jsonOutput {
|
||||
outputJSON(entries)
|
||||
return
|
||||
}
|
||||
|
||||
if len(entries) == 0 {
|
||||
fmt.Println("No formulas found.")
|
||||
fmt.Println("\nSearch paths:")
|
||||
for _, p := range searchPaths {
|
||||
fmt.Printf(" %s\n", p)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
fmt.Printf("📜 Formulas (%d found)\n\n", len(entries))
|
||||
|
||||
// Group by type
|
||||
byType := make(map[string][]FormulaListEntry)
|
||||
for _, e := range entries {
|
||||
byType[e.Type] = append(byType[e.Type], e)
|
||||
}
|
||||
|
||||
// Print in type order: workflow, expansion, aspect
|
||||
typeOrder := []string{"workflow", "expansion", "aspect"}
|
||||
for _, t := range typeOrder {
|
||||
typeEntries := byType[t]
|
||||
if len(typeEntries) == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
typeIcon := getTypeIcon(t)
|
||||
fmt.Printf("%s %s:\n", typeIcon, strings.Title(t))
|
||||
|
||||
for _, e := range typeEntries {
|
||||
varInfo := ""
|
||||
if e.Vars > 0 {
|
||||
varInfo = fmt.Sprintf(" (%d vars)", e.Vars)
|
||||
}
|
||||
fmt.Printf(" %-25s %s%s\n", e.Name, e.Description, varInfo)
|
||||
}
|
||||
fmt.Println()
|
||||
}
|
||||
}
|
||||
|
||||
func runFormulaShow(cmd *cobra.Command, args []string) {
|
||||
name := args[0]
|
||||
|
||||
// Create parser with default search paths
|
||||
parser := formula.NewParser()
|
||||
|
||||
// Try to load the formula
|
||||
f, err := parser.LoadByName(name)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
|
||||
fmt.Fprintf(os.Stderr, "\nSearch paths:\n")
|
||||
for _, p := range getFormulaSearchPaths() {
|
||||
fmt.Fprintf(os.Stderr, " %s\n", p)
|
||||
}
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
if jsonOutput {
|
||||
outputJSON(f)
|
||||
return
|
||||
}
|
||||
|
||||
// Print header
|
||||
typeIcon := getTypeIcon(string(f.Type))
|
||||
fmt.Printf("\n%s %s\n", typeIcon, f.Formula)
|
||||
fmt.Printf(" Type: %s\n", f.Type)
|
||||
if f.Description != "" {
|
||||
fmt.Printf(" Description: %s\n", f.Description)
|
||||
}
|
||||
fmt.Printf(" Source: %s\n", f.Source)
|
||||
|
||||
// Print extends
|
||||
if len(f.Extends) > 0 {
|
||||
fmt.Printf("\n%s Extends:\n", ui.RenderAccent("📎"))
|
||||
for _, ext := range f.Extends {
|
||||
fmt.Printf(" - %s\n", ext)
|
||||
}
|
||||
}
|
||||
|
||||
// Print variables
|
||||
if len(f.Vars) > 0 {
|
||||
fmt.Printf("\n%s Variables:\n", ui.RenderWarn("📝"))
|
||||
// Sort for consistent output
|
||||
varNames := make([]string, 0, len(f.Vars))
|
||||
for name := range f.Vars {
|
||||
varNames = append(varNames, name)
|
||||
}
|
||||
sort.Strings(varNames)
|
||||
|
||||
for _, name := range varNames {
|
||||
v := f.Vars[name]
|
||||
attrs := []string{}
|
||||
if v.Required {
|
||||
attrs = append(attrs, ui.RenderFail("required"))
|
||||
}
|
||||
if v.Default != "" {
|
||||
attrs = append(attrs, fmt.Sprintf("default=%q", v.Default))
|
||||
}
|
||||
if len(v.Enum) > 0 {
|
||||
attrs = append(attrs, fmt.Sprintf("enum=[%s]", strings.Join(v.Enum, ",")))
|
||||
}
|
||||
if v.Pattern != "" {
|
||||
attrs = append(attrs, fmt.Sprintf("pattern=%q", v.Pattern))
|
||||
}
|
||||
attrStr := ""
|
||||
if len(attrs) > 0 {
|
||||
attrStr = fmt.Sprintf(" [%s]", strings.Join(attrs, ", "))
|
||||
}
|
||||
desc := ""
|
||||
if v.Description != "" {
|
||||
desc = fmt.Sprintf(": %s", v.Description)
|
||||
}
|
||||
fmt.Printf(" {{%s}}%s%s\n", name, desc, attrStr)
|
||||
}
|
||||
}
|
||||
|
||||
// Print steps
|
||||
if len(f.Steps) > 0 {
|
||||
fmt.Printf("\n%s Steps (%d):\n", ui.RenderPass("🌲"), countSteps(f.Steps))
|
||||
printFormulaStepsTree(f.Steps, " ")
|
||||
}
|
||||
|
||||
// Print template (for expansion formulas)
|
||||
if len(f.Template) > 0 {
|
||||
fmt.Printf("\n%s Template (%d steps):\n", ui.RenderAccent("📐"), len(f.Template))
|
||||
printFormulaStepsTree(f.Template, " ")
|
||||
}
|
||||
|
||||
// Print advice rules
|
||||
if len(f.Advice) > 0 {
|
||||
fmt.Printf("\n%s Advice:\n", ui.RenderWarn("💡"))
|
||||
for _, a := range f.Advice {
|
||||
parts := []string{}
|
||||
if a.Before != nil {
|
||||
parts = append(parts, fmt.Sprintf("before: %s", a.Before.ID))
|
||||
}
|
||||
if a.After != nil {
|
||||
parts = append(parts, fmt.Sprintf("after: %s", a.After.ID))
|
||||
}
|
||||
if a.Around != nil {
|
||||
parts = append(parts, "around")
|
||||
}
|
||||
fmt.Printf(" %s → %s\n", a.Target, strings.Join(parts, ", "))
|
||||
}
|
||||
}
|
||||
|
||||
// Print compose rules
|
||||
if f.Compose != nil {
|
||||
hasCompose := len(f.Compose.BondPoints) > 0 || len(f.Compose.Expand) > 0 ||
|
||||
len(f.Compose.Map) > 0 || len(f.Compose.Aspects) > 0
|
||||
|
||||
if hasCompose {
|
||||
fmt.Printf("\n%s Composition:\n", ui.RenderAccent("🔗"))
|
||||
|
||||
if len(f.Compose.BondPoints) > 0 {
|
||||
fmt.Printf(" Bond Points:\n")
|
||||
for _, bp := range f.Compose.BondPoints {
|
||||
loc := ""
|
||||
if bp.AfterStep != "" {
|
||||
loc = fmt.Sprintf("after %s", bp.AfterStep)
|
||||
} else if bp.BeforeStep != "" {
|
||||
loc = fmt.Sprintf("before %s", bp.BeforeStep)
|
||||
}
|
||||
fmt.Printf(" - %s (%s)\n", bp.ID, loc)
|
||||
}
|
||||
}
|
||||
|
||||
if len(f.Compose.Expand) > 0 {
|
||||
fmt.Printf(" Expansions:\n")
|
||||
for _, e := range f.Compose.Expand {
|
||||
fmt.Printf(" - %s → %s\n", e.Target, e.With)
|
||||
}
|
||||
}
|
||||
|
||||
if len(f.Compose.Map) > 0 {
|
||||
fmt.Printf(" Maps:\n")
|
||||
for _, m := range f.Compose.Map {
|
||||
fmt.Printf(" - %s → %s\n", m.Select, m.With)
|
||||
}
|
||||
}
|
||||
|
||||
if len(f.Compose.Aspects) > 0 {
|
||||
fmt.Printf(" Aspects: %s\n", strings.Join(f.Compose.Aspects, ", "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Print pointcuts (for aspects)
|
||||
if len(f.Pointcuts) > 0 {
|
||||
fmt.Printf("\n%s Pointcuts:\n", ui.RenderWarn("🎯"))
|
||||
for _, p := range f.Pointcuts {
|
||||
parts := []string{}
|
||||
if p.Glob != "" {
|
||||
parts = append(parts, fmt.Sprintf("glob=%q", p.Glob))
|
||||
}
|
||||
if p.Type != "" {
|
||||
parts = append(parts, fmt.Sprintf("type=%q", p.Type))
|
||||
}
|
||||
if p.Label != "" {
|
||||
parts = append(parts, fmt.Sprintf("label=%q", p.Label))
|
||||
}
|
||||
fmt.Printf(" - %s\n", strings.Join(parts, ", "))
|
||||
}
|
||||
}
|
||||
|
||||
fmt.Println()
|
||||
}
|
||||
|
||||
// getFormulaSearchPaths returns the formula search paths in priority order.
|
||||
func getFormulaSearchPaths() []string {
|
||||
var paths []string
|
||||
|
||||
// Project-level formulas
|
||||
if cwd, err := os.Getwd(); err == nil {
|
||||
paths = append(paths, filepath.Join(cwd, ".beads", "formulas"))
|
||||
}
|
||||
|
||||
// User-level formulas
|
||||
if home, err := os.UserHomeDir(); err == nil {
|
||||
paths = append(paths, filepath.Join(home, ".beads", "formulas"))
|
||||
// Gas Town formulas
|
||||
paths = append(paths, filepath.Join(home, "gt", ".beads", "formulas"))
|
||||
}
|
||||
|
||||
return paths
|
||||
}
|
||||
|
||||
// scanFormulaDir scans a directory for formula files.
|
||||
func scanFormulaDir(dir string) ([]*formula.Formula, error) {
|
||||
entries, err := os.ReadDir(dir)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
parser := formula.NewParser(dir)
|
||||
var formulas []*formula.Formula
|
||||
|
||||
for _, entry := range entries {
|
||||
if entry.IsDir() {
|
||||
continue
|
||||
}
|
||||
if !strings.HasSuffix(entry.Name(), formula.FormulaExt) {
|
||||
continue
|
||||
}
|
||||
|
||||
path := filepath.Join(dir, entry.Name())
|
||||
f, err := parser.ParseFile(path)
|
||||
if err != nil {
|
||||
continue // Skip invalid formulas
|
||||
}
|
||||
formulas = append(formulas, f)
|
||||
}
|
||||
|
||||
return formulas, nil
|
||||
}
|
||||
|
||||
// countSteps recursively counts steps including children.
|
||||
func countSteps(steps []*formula.Step) int {
|
||||
count := len(steps)
|
||||
for _, s := range steps {
|
||||
count += countSteps(s.Children)
|
||||
}
|
||||
return count
|
||||
}
|
||||
|
||||
// truncateDescription truncates a description to maxLen characters.
|
||||
func truncateDescription(desc string, maxLen int) string {
|
||||
// Take first line only
|
||||
if idx := strings.Index(desc, "\n"); idx >= 0 {
|
||||
desc = desc[:idx]
|
||||
}
|
||||
if len(desc) > maxLen {
|
||||
return desc[:maxLen-3] + "..."
|
||||
}
|
||||
return desc
|
||||
}
|
||||
|
||||
// getTypeIcon returns an icon for the formula type.
|
||||
func getTypeIcon(t string) string {
|
||||
switch t {
|
||||
case "workflow":
|
||||
return "📋"
|
||||
case "expansion":
|
||||
return "📐"
|
||||
case "aspect":
|
||||
return "🎯"
|
||||
default:
|
||||
return "📜"
|
||||
}
|
||||
}
|
||||
|
||||
// printFormulaStepsTree prints steps in a tree format.
|
||||
func printFormulaStepsTree(steps []*formula.Step, indent string) {
|
||||
for i, step := range steps {
|
||||
connector := "├──"
|
||||
if i == len(steps)-1 {
|
||||
connector = "└──"
|
||||
}
|
||||
|
||||
// Collect dependency info
|
||||
var depParts []string
|
||||
if len(step.DependsOn) > 0 {
|
||||
depParts = append(depParts, fmt.Sprintf("depends: %s", strings.Join(step.DependsOn, ", ")))
|
||||
}
|
||||
if len(step.Needs) > 0 {
|
||||
depParts = append(depParts, fmt.Sprintf("needs: %s", strings.Join(step.Needs, ", ")))
|
||||
}
|
||||
if step.WaitsFor != "" {
|
||||
depParts = append(depParts, fmt.Sprintf("waits_for: %s", step.WaitsFor))
|
||||
}
|
||||
|
||||
depStr := ""
|
||||
if len(depParts) > 0 {
|
||||
depStr = fmt.Sprintf(" [%s]", strings.Join(depParts, ", "))
|
||||
}
|
||||
|
||||
typeStr := ""
|
||||
if step.Type != "" && step.Type != "task" {
|
||||
typeStr = fmt.Sprintf(" (%s)", step.Type)
|
||||
}
|
||||
|
||||
fmt.Printf("%s%s %s: %s%s%s\n", indent, connector, step.ID, step.Title, typeStr, depStr)
|
||||
|
||||
if len(step.Children) > 0 {
|
||||
childIndent := indent
|
||||
if i == len(steps)-1 {
|
||||
childIndent += " "
|
||||
} else {
|
||||
childIndent += "│ "
|
||||
}
|
||||
printFormulaStepsTree(step.Children, childIndent)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func init() {
|
||||
formulaListCmd.Flags().String("type", "", "Filter by type (workflow, expansion, aspect)")
|
||||
|
||||
formulaCmd.AddCommand(formulaListCmd)
|
||||
formulaCmd.AddCommand(formulaShowCmd)
|
||||
rootCmd.AddCommand(formulaCmd)
|
||||
}
|
||||
Reference in New Issue
Block a user