feat(cli): add 'generate agents' and 'generate all' commands

New simplified commands for multi-agent-spec workflow:

generate agents:
- Reads from specs/agents/*.md (YAML frontmatter)
- Uses specs/deployments/<target>.json for output locations
- Flags: --specs, --target, --output

generate all:
- Combines plugins and agents generation
- Generates complete plugin packages per platform
- Flags: --specs, --target, --output, --platforms

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: grokify

cmd/assistantkit/generate.go

@@ -71,9 +71,64 @@ Example:
 	RunE: runGenerateDeployment,
 }
 
+var (
+	agentsSpecDir   string
+	agentsTarget    string
+	agentsOutputDir string
+)
+
+var generateAgentsCmd = &cobra.Command{
+	Use:   "agents",
+	Short: "Generate agents from specs directory (simplified)",
+	Long: `Generate platform-specific agents from a specs directory.
+
+This is a simplified command that reads from specs/agents/*.md and uses
+specs/deployments/<target>.json to determine output locations.
+
+The specs directory should contain:
+  - agents/: Agent definitions (*.md with YAML frontmatter)
+  - deployments/: Deployment definitions (*.json, defaults to local.json)
+
+Example:
+  assistantkit generate agents
+  assistantkit generate agents --specs=specs --target=local --output=.`,
+	RunE: runGenerateAgents,
+}
+
+var (
+	allSpecsDir  string
+	allTarget    string
+	allOutputDir string
+	allPlatforms []string
+)
+
+var generateAllCmd = &cobra.Command{
+	Use:   "all",
+	Short: "Generate all plugin artifacts from a unified specs directory",
+	Long: `Generate all platform-specific artifacts from a unified specs directory.
+
+This command combines 'generate plugins' and 'generate agents' into a single
+operation. It reads all specs from a single directory and generates complete
+plugin packages for each platform.
+
+The specs directory should contain:
+  - plugin.json: Plugin metadata
+  - commands/: Command definitions (*.md or *.json)
+  - skills/: Skill definitions (*.md or *.json)
+  - agents/: Agent definitions (*.md with YAML frontmatter)
+  - deployments/: Deployment definitions (*.json)
+
+Example:
+  assistantkit generate all --specs=specs --target=local
+  assistantkit generate all --specs=specs --target=local --output=. --platforms=claude,kiro,gemini`,
+	RunE: runGenerateAll,
+}
+
 func init() {
 	generateCmd.AddCommand(generatePluginsCmd)
 	generateCmd.AddCommand(generateDeploymentCmd)
+	generateCmd.AddCommand(generateAgentsCmd)
+	generateCmd.AddCommand(generateAllCmd)
 
 	generatePluginsCmd.Flags().StringVar(&specDir, "spec", "plugins/spec", "Path to canonical spec directory")
 	generatePluginsCmd.Flags().StringVar(&outputDir, "output", "plugins", "Output directory for generated plugins")
@@ -83,6 +138,15 @@ func init() {
 	generateDeploymentCmd.Flags().StringVar(&deploymentSpecDir, "specs", "specs", "Path to multi-agent-spec directory")
 	generateDeploymentCmd.Flags().StringVar(&deploymentFile, "deployment", "", "Path to deployment definition file (required)")
 	_ = generateDeploymentCmd.MarkFlagRequired("deployment")
+
+	generateAgentsCmd.Flags().StringVar(&agentsSpecDir, "specs", "specs", "Path to specs directory")
+	generateAgentsCmd.Flags().StringVar(&agentsTarget, "target", "local", "Deployment target (looks for specs/deployments/<target>.json)")
+	generateAgentsCmd.Flags().StringVar(&agentsOutputDir, "output", ".", "Output base directory (repo root)")
+
+	generateAllCmd.Flags().StringVar(&allSpecsDir, "specs", "specs", "Path to unified specs directory")
+	generateAllCmd.Flags().StringVar(&allTarget, "target", "local", "Deployment target (looks for specs/deployments/<target>.json)")
+	generateAllCmd.Flags().StringVar(&allOutputDir, "output", ".", "Output base directory (repo root)")
+	generateAllCmd.Flags().StringSliceVar(&allPlatforms, "platforms", []string{"claude", "kiro", "gemini"}, "Platforms to generate")
 }
 
 func runGenerateDeployment(cmd *cobra.Command, args []string) error {
@@ -172,3 +236,106 @@ func runGeneratePlugins(cmd *cobra.Command, args []string) error {
 	fmt.Println("\nDone!")
 	return nil
 }
+
+func runGenerateAgents(cmd *cobra.Command, args []string) error {
+	// Resolve paths
+	absSpecsDir, err := filepath.Abs(agentsSpecDir)
+	if err != nil {
+		return fmt.Errorf("resolving specs dir: %w", err)
+	}
+
+	absOutputDir, err := filepath.Abs(agentsOutputDir)
+	if err != nil {
+		return fmt.Errorf("resolving output dir: %w", err)
+	}
+
+	// Validate specs directory exists
+	if _, err := os.Stat(absSpecsDir); os.IsNotExist(err) {
+		return fmt.Errorf("specs directory not found: %s", absSpecsDir)
+	}
+
+	// Print header
+	fmt.Println("=== AssistantKit Agent Generator ===")
+	fmt.Printf("Specs directory: %s\n", absSpecsDir)
+	fmt.Printf("Target: %s\n", agentsTarget)
+	fmt.Printf("Output directory: %s\n", absOutputDir)
+	fmt.Println()
+
+	// Generate agents
+	result, err := generate.Agents(absSpecsDir, agentsTarget, absOutputDir)
+	if err != nil {
+		return fmt.Errorf("generating agents: %w", err)
+	}
+
+	// Print results
+	fmt.Printf("Team: %s\n", result.TeamName)
+	fmt.Printf("Loaded: %d agents\n\n", result.AgentCount)
+
+	fmt.Println("Generated targets:")
+	for _, target := range result.TargetsGenerated {
+		dir := result.GeneratedDirs[target]
+		fmt.Printf("  - %s: %s\n", target, dir)
+	}
+
+	fmt.Println("\nDone!")
+	return nil
+}
+
+func runGenerateAll(cmd *cobra.Command, args []string) error {
+	// Resolve paths
+	absSpecsDir, err := filepath.Abs(allSpecsDir)
+	if err != nil {
+		return fmt.Errorf("resolving specs dir: %w", err)
+	}
+
+	absOutputDir, err := filepath.Abs(allOutputDir)
+	if err != nil {
+		return fmt.Errorf("resolving output dir: %w", err)
+	}
+
+	// Validate specs directory exists
+	if _, err := os.Stat(absSpecsDir); os.IsNotExist(err) {
+		return fmt.Errorf("specs directory not found: %s", absSpecsDir)
+	}
+
+	// Print header
+	fmt.Println("=== AssistantKit Unified Generator ===")
+	fmt.Printf("Specs directory: %s\n", absSpecsDir)
+	fmt.Printf("Output directory: %s\n", absOutputDir)
+	fmt.Printf("Target: %s\n", allTarget)
+	fmt.Printf("Platforms: %s\n", strings.Join(allPlatforms, ", "))
+	fmt.Println()
+
+	// Step 1: Generate plugins (commands, skills, plugin manifest)
+	pluginsOutputDir := filepath.Join(absOutputDir, "plugins")
+	fmt.Println("1. Generating plugins (commands, skills, manifest)...")
+
+	pluginResult, err := generate.Plugins(absSpecsDir, pluginsOutputDir, allPlatforms)
+	if err != nil {
+		return fmt.Errorf("generating plugins: %w", err)
+	}
+
+	fmt.Printf("   Loaded: %d commands, %d skills\n", pluginResult.CommandCount, pluginResult.SkillCount)
+	for platform, dir := range pluginResult.GeneratedDirs {
+		fmt.Printf("   Generated %s: %s\n", platform, dir)
+	}
+	fmt.Println()
+
+	// Step 2: Generate agents from deployment target
+	fmt.Println("2. Generating agents from deployment target...")
+
+	agentResult, err := generate.Agents(absSpecsDir, allTarget, absOutputDir)
+	if err != nil {
+		return fmt.Errorf("generating agents: %w", err)
+	}
+
+	fmt.Printf("   Team: %s\n", agentResult.TeamName)
+	fmt.Printf("   Loaded: %d agents\n", agentResult.AgentCount)
+	for _, target := range agentResult.TargetsGenerated {
+		dir := agentResult.GeneratedDirs[target]
+		fmt.Printf("   Generated %s: %s\n", target, dir)
+	}
+
+	fmt.Println("\nDone!")
+	return nil
+}

generate/generate.go

@@ -141,65 +141,17 @@ func loadCommands(dir string) ([]*commands.Command, error) {
 		return nil, nil // Commands are optional
 	}
 
-	entries, err := os.ReadDir(dir)
-	if err != nil {
-		return nil, err
-	}
-
-	var cmds []*commands.Command
-	for _, entry := range entries {
-		if entry.IsDir() || filepath.Ext(entry.Name()) != ".json" {
-			continue
-		}
-
-		path := filepath.Join(dir, entry.Name())
-		data, err := os.ReadFile(path)
-		if err != nil {
-			return nil, err
-		}
-
-		var cmd commands.Command
-		if err := json.Unmarshal(data, &cmd); err != nil {
-			return nil, fmt.Errorf("parse %s: %w", entry.Name(), err)
-		}
-
-		cmds = append(cmds, &cmd)
-	}
-
-	return cmds, nil
+	// Use ReadCanonicalDir which supports both .json and .md files
+	return commands.ReadCanonicalDir(dir)
 }
 
 func loadSkills(dir string) ([]*skills.Skill, error) {
 	if _, err := os.Stat(dir); os.IsNotExist(err) {
 		return nil, nil // Skills are optional
 	}
 
-	entries, err := os.ReadDir(dir)
-	if err != nil {
-		return nil, err
-	}
-
-	var skls []*skills.Skill
-	for _, entry := range entries {
-		if entry.IsDir() || filepath.Ext(entry.Name()) != ".json" {
-			continue
-		}
-
-		path := filepath.Join(dir, entry.Name())
-		data, err := os.ReadFile(path)
-		if err != nil {
-			return nil, err
-		}
-
-		var skl skills.Skill
-		if err := json.Unmarshal(data, &skl); err != nil {
-			return nil, fmt.Errorf("parse %s: %w", entry.Name(), err)
-		}
-
-		skls = append(skls, &skl)
-	}
-
-	return skls, nil
+	// Use ReadCanonicalDir which supports both .json and .md files
+	return skills.ReadCanonicalDir(dir)
 }
 
 func loadAgents(dir string) ([]*agents.Agent, error) {
@@ -831,3 +783,71 @@ func generateGeminiCLIDeployment(agts []*agents.Agent, outputDir string) error {
 
 	return nil
 }
+
+// AgentsResult contains the results of simplified agent generation.
+type AgentsResult struct {
+	// AgentCount is the number of agents loaded.
+	AgentCount int
+
+	// TeamName is the name of the team being deployed.
+	TeamName string
+
+	// TargetsGenerated lists the names of generated targets.
+	TargetsGenerated []string
+
+	// GeneratedDirs maps target names to their output directories.
+	GeneratedDirs map[string]string
+}
+
+// Agents generates platform-specific agents from a specs directory with simplified options.
+//
+// The specsDir should contain:
+//   - agents/: Agent definitions (*.md with YAML frontmatter)
+//   - deployments/: Deployment definitions (*.json)
+//
+// The target parameter specifies which deployment file to use (looks for {target}.json).
+// The outputDir is the base directory for resolving relative output paths in the deployment.
+func Agents(specsDir, target, outputDir string) (*AgentsResult, error) {
+	result := &AgentsResult{
+		GeneratedDirs: make(map[string]string),
+	}
+
+	// Load agents from multi-agent-spec format
+	agentsDir := filepath.Join(specsDir, "agents")
+	agts, err := loadMultiAgentSpecAgents(agentsDir)
+	if err != nil {
+		return nil, fmt.Errorf("loading agents: %w", err)
+	}
+	result.AgentCount = len(agts)
+
+	// Construct deployment file path
+	deploymentFile := filepath.Join(specsDir, "deployments", target+".json")
+	if _, err := os.Stat(deploymentFile); os.IsNotExist(err) {
+		return nil, fmt.Errorf("deployment file not found: %s", deploymentFile)
+	}
+
+	// Load deployment
+	deployment, err := loadDeployment(deploymentFile)
+	if err != nil {
+		return nil, fmt.Errorf("loading deployment: %w", err)
+	}
+	result.TeamName = deployment.Team
+
+	// Generate each target
+	for _, tgt := range deployment.Targets {
+		// Resolve output path relative to outputDir (not specsDir)
+		targetOutputDir := tgt.Output
+		if !filepath.IsAbs(targetOutputDir) {
+			targetOutputDir = filepath.Join(outputDir, targetOutputDir)
+		}
+
+		if err := generateDeploymentTarget(tgt, agts, targetOutputDir); err != nil {
+			return nil, fmt.Errorf("generating target %s: %w", tgt.Name, err)
+		}
+
+		result.TargetsGenerated = append(result.TargetsGenerated, tgt.Name)
+		result.GeneratedDirs[tgt.Name] = targetOutputDir
+	}
+
+	return result, nil
+}