@agentspan/agentspan 0.0.3

package/cmd/init.go

@@ -0,0 +1,83 @@
+// Copyright (c) 2025 AgentSpan
+// Licensed under the MIT License. See LICENSE file in the project root for details.
+
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+	"gopkg.in/yaml.v3"
+)
+
+var (
+	initModel    string
+	initStrategy string
+	initFormat   string
+)
+
+var initCmd = &cobra.Command{
+	Use:   "init <agent-name>",
+	Short: "Create a new agent config file",
+	Long:  "Generate a starter agent config YAML/JSON file with sensible defaults.",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		name := args[0]
+		model := initModel
+		if model == "" {
+			model = "openai/gpt-4o"
+		}
+
+		agentConfig := map[string]interface{}{
+			"name":         name,
+			"description":  fmt.Sprintf("%s agent", name),
+			"model":        model,
+			"instructions": fmt.Sprintf("You are %s, a helpful AI assistant.", name),
+			"maxTurns":     25,
+			"tools":        []interface{}{},
+		}
+
+		if initStrategy != "" {
+			agentConfig["strategy"] = initStrategy
+		}
+
+		var data []byte
+		var ext string
+		var err error
+
+		if initFormat == "json" {
+			ext = "json"
+			data, err = marshalJSON(agentConfig)
+		} else {
+			ext = "yaml"
+			data, err = yaml.Marshal(agentConfig)
+		}
+		if err != nil {
+			return err
+		}
+
+		filename := fmt.Sprintf("%s.%s", name, ext)
+		if err := os.WriteFile(filename, data, 0o644); err != nil {
+			return fmt.Errorf("write file: %w", err)
+		}
+
+		color.Green("Created %s", filename)
+		fmt.Println("\nEdit the file to add tools, instructions, and other settings.")
+		fmt.Printf("Run with: agentspan agent run --name %s \"your prompt here\"\n", name)
+		return nil
+	},
+}
+
+func marshalJSON(v interface{}) ([]byte, error) {
+	return json.MarshalIndent(v, "", "  ")
+}
+
+func init() {
+	initCmd.Flags().StringVarP(&initModel, "model", "m", "", "LLM model (default: openai/gpt-4o)")
+	initCmd.Flags().StringVarP(&initStrategy, "strategy", "s", "", "Multi-agent strategy (handoff, sequential, parallel, etc.)")
+	initCmd.Flags().StringVarP(&initFormat, "format", "f", "yaml", "Output format: yaml or json")
+	agentCmd.AddCommand(initCmd)
+}

package/cmd/list.go

@@ -0,0 +1,55 @@
+// Copyright (c) 2025 AgentSpan
+// Licensed under the MIT License. See LICENSE file in the project root for details.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"text/tabwriter"
+	"time"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+var listCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List all registered agents",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		cfg := getConfig()
+		c := newClient(cfg)
+
+		agents, err := c.ListAgents()
+		if err != nil {
+			return fmt.Errorf("failed to list agents: %w", err)
+		}
+
+		if len(agents) == 0 {
+			color.Yellow("No agents registered.")
+			return nil
+		}
+
+		w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+		fmt.Fprintln(w, "NAME\tVERSION\tTYPE\tDESCRIPTION\tUPDATED")
+		fmt.Fprintln(w, "----\t-------\t----\t-----------\t-------")
+
+		for _, a := range agents {
+			updated := ""
+			if a.UpdateTime != nil {
+				t := time.UnixMilli(*a.UpdateTime)
+				updated = t.Format("2006-01-02 15:04")
+			}
+			desc := truncate(a.Description, 40)
+			fmt.Fprintf(w, "%s\t%d\t%s\t%s\t%s\n", a.Name, a.Version, a.Type, desc, updated)
+		}
+		w.Flush()
+
+		fmt.Printf("\n%d agent(s) found.\n", len(agents))
+		return nil
+	},
+}
+
+func init() {
+	agentCmd.AddCommand(listCmd)
+}

package/cmd/respond.go

@@ -0,0 +1,56 @@
+// Copyright (c) 2025 AgentSpan
+// Licensed under the MIT License. See LICENSE file in the project root for details.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+var (
+	respondApprove bool
+	respondDeny    bool
+	respondReason  string
+	respondMessage string
+)
+
+var respondCmd = &cobra.Command{
+	Use:   "respond <workflow-id>",
+	Short: "Respond to a human-in-the-loop task",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		cfg := getConfig()
+		c := newClient(cfg)
+
+		approved := true
+		if respondDeny {
+			approved = false
+		}
+
+		if err := c.Respond(args[0], approved, respondReason, respondMessage); err != nil {
+			return fmt.Errorf("failed to respond: %w", err)
+		}
+
+		if approved {
+			color.Green("Response sent: approved")
+		} else {
+			color.Yellow("Response sent: denied")
+		}
+		if respondReason != "" {
+			fmt.Printf("  Reason: %s\n", respondReason)
+		}
+
+		return nil
+	},
+}
+
+func init() {
+	respondCmd.Flags().BoolVar(&respondApprove, "approve", false, "Approve the pending action")
+	respondCmd.Flags().BoolVar(&respondDeny, "deny", false, "Deny the pending action")
+	respondCmd.Flags().StringVar(&respondReason, "reason", "", "Reason for the response")
+	respondCmd.Flags().StringVarP(&respondMessage, "message", "m", "", "Message to send back")
+	agentCmd.AddCommand(respondCmd)
+}

package/cmd/root.go

@@ -0,0 +1,44 @@
+// Copyright (c) 2025 AgentSpan
+// Licensed under the MIT License. See LICENSE file in the project root for details.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	serverURL string
+	Version   = "dev"
+	Commit    = "none"
+	Date      = "unknown"
+)
+
+var rootCmd = &cobra.Command{
+	Use:   "agentspan",
+	Short: "CLI for the AgentSpan runtime",
+	Long:  "Create, run, and manage AI agents powered by the AgentSpan runtime.",
+}
+
+var versionCmd = &cobra.Command{
+	Use:   "version",
+	Short: "Print the CLI version",
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Printf("agentspan %s (commit: %s, built: %s)\n", Version, Commit, Date)
+	},
+}
+
+func Execute() {
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func init() {
+	rootCmd.PersistentFlags().StringVar(&serverURL, "server", "", "Runtime server URL (default: http://localhost:8080)")
+	rootCmd.AddCommand(versionCmd)
+}

package/cmd/run.go

@@ -0,0 +1,116 @@
+// Copyright (c) 2025 AgentSpan
+// Licensed under the MIT License. See LICENSE file in the project root for details.
+
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/agentspan/agentspan/cli/client"
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+var (
+	runAgentName string
+	runSessionID string
+	runNoStream  bool
+)
+
+var runCmd = &cobra.Command{
+	Use:   "run [prompt]",
+	Short: "Start an agent and stream its output",
+	Long: `Start a registered agent by name with a prompt,
+and stream the execution events in real-time.
+
+The agent must have been previously registered via the /api/agent/start endpoint.
+Alternatively, provide a config file with --config.`,
+	Args: cobra.MinimumNArgs(1),
+	RunE: runAgent,
+}
+
+var runConfigFile string
+
+func init() {
+	runCmd.Flags().StringVar(&runAgentName, "name", "", "Name of a registered agent to run")
+	runCmd.Flags().StringVar(&runConfigFile, "config", "", "Path to agent config file (YAML/JSON)")
+	runCmd.Flags().StringVar(&runSessionID, "session", "", "Session ID for conversation continuity")
+	runCmd.Flags().BoolVar(&runNoStream, "no-stream", false, "Don't stream events, just return the workflow ID")
+	agentCmd.AddCommand(runCmd)
+}
+
+func runAgent(cmd *cobra.Command, args []string) error {
+	prompt := strings.Join(args, " ")
+
+	cfg := getConfig()
+	c := newClient(cfg)
+
+	var startReq *client.StartRequest
+
+	if runConfigFile != "" {
+		// Config file mode (existing behavior)
+		agentConfig, err := loadAgentConfig(runConfigFile)
+		if err != nil {
+			return err
+		}
+		bold := color.New(color.Bold)
+		bold.Printf("Starting agent: %s\n", agentConfig["name"])
+		startReq = &client.StartRequest{
+			AgentConfig: agentConfig,
+			Prompt:      prompt,
+		}
+	} else if runAgentName != "" {
+		// Name mode: fetch agent def, then start with it
+		bold := color.New(color.Bold)
+		bold.Printf("Starting agent: %s\n", runAgentName)
+
+		agentDef, err := c.GetAgent(runAgentName, nil)
+		if err != nil {
+			return fmt.Errorf("failed to get agent '%s': %w", runAgentName, err)
+		}
+		startReq = &client.StartRequest{
+			AgentConfig: agentDef,
+			Prompt:      prompt,
+		}
+	} else {
+		return fmt.Errorf("specify either --name or --config")
+	}
+
+	if runSessionID != "" {
+		startReq.SessionID = runSessionID
+	}
+
+	resp, err := c.Start(startReq)
+	if err != nil {
+		return fmt.Errorf("failed to start agent: %w", err)
+	}
+
+	fmt.Printf("Workflow: %s (ID: %s)\n", resp.WorkflowName, resp.WorkflowID)
+
+	if runNoStream {
+		return nil
+	}
+
+	fmt.Println()
+	return streamWorkflow(c, resp.WorkflowID)
+}
+
+func streamWorkflow(c *client.Client, workflowID string) error {
+	events := make(chan client.SSEEvent, 100)
+	done := make(chan error, 1)
+
+	c.Stream(workflowID, "", events, done)
+
+	for {
+		select {
+		case evt, ok := <-events:
+			if !ok {
+				return nil
+			}
+			printSSEEvent(evt)
+		case err := <-done:
+			return err
+		}
+	}
+}