feat: use rules.json for slug when publishing

Author: sestinj

cmd/publish.go

@@ -9,31 +9,32 @@ import (
 
 	"rules-cli/internal/auth"
 	"rules-cli/internal/registry"
+	"rules-cli/internal/ruleset"
 
 	"github.com/fatih/color"
 	"github.com/spf13/cobra"
 )
 
 var (
-	slug       string
 	visibility string
 )
 
 // publishCmd represents the publish command
 var publishCmd = &cobra.Command{
-	Use:   "publish <rule-file>",
+	Use:   "publish [path]",
 	Short: "Publish a rule file to the registry",
 	Long: `Publishes a rule file to the registry.
 
 This command requires authentication and will prompt you to login if you're not already.
-You must specify the organization/ruleset slug to publish to.
+The slug is automatically determined from rules.json in the current directory or specified path.
 
 The visibility can be set to "public" (default) or "private".
 
 Examples:
-  rules publish my-rule.md --slug my-org/my-rules
-  rules publish my-rule.md --slug my-org/my-rules --visibility private`,
-	Args: cobra.ExactArgs(1),
+  rules publish                    # Publish from current directory
+  rules publish ./my-rules         # Publish from specified directory
+  rules publish --visibility private`,
+	Args: cobra.MaximumNArgs(1),
 	RunE: runPublishCommand,
 }
 
@@ -45,30 +46,86 @@ func runPublishCommand(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("authentication required to publish rules")
 	}
 
-	// Validate the slug format
-	if slug == "" {
-		return fmt.Errorf("--slug is required and must be in the format 'organization/ruleset'")
+	// Validate the visibility
+	if visibility != "public" && visibility != "private" {
+		return fmt.Errorf("visibility must be either 'public' or 'private'")
 	}
 
-	if !strings.Contains(slug, "/") {
-		return fmt.Errorf("slug must be in the format 'organization/ruleset'")
+	// Determine the path to look for rules.json
+	var rulesPath string
+	if len(args) > 0 {
+		rulesPath = args[0]
 	}
 
-	parts := strings.Split(slug, "/")
-	if len(parts) != 2 || parts[0] == "" || parts[1] == "" {
-		return fmt.Errorf("slug must be in the format 'organization/ruleset'")
+	// Load ruleset from the specified path or current directory
+	rs, err := ruleset.LoadRuleSetFromPath(rulesPath)
+	if err != nil {
+		return fmt.Errorf("failed to load rules.json: %w", err)
 	}
 
-	ownerSlug := parts[0]
-	ruleSlug := parts[1]
+	// Validate that the ruleset has a name
+	if rs.Name == "" {
+		return fmt.Errorf("rules.json must have a 'name' field")
+	}
 
-	// Validate the visibility
-	if visibility != "public" && visibility != "private" {
-		return fmt.Errorf("visibility must be either 'public' or 'private'")
+	// Create registry client and get user info
+	authConfig := auth.LoadAuthConfig()
+	client := registry.NewClient(cfg.RegistryURL)
+	client.SetAuthToken(authConfig.AccessToken)
+
+	// Get user information to determine the organization slug
+	userInfo, err := client.GetUserInfo()
+	if err != nil {
+		return fmt.Errorf("failed to get user information: %w", err)
+	}
+
+	// Determine the organization slug
+	ownerSlug := userInfo.OrgSlug
+	if ownerSlug == "" {
+		// Fallback to username if orgSlug is not available
+		ownerSlug = userInfo.Username
+		if ownerSlug == "" {
+			// Fallback to email prefix if username is not available
+			if userInfo.Email != "" {
+				ownerSlug = strings.Split(userInfo.Email, "@")[0]
+			} else {
+				return fmt.Errorf("could not determine organization slug from user information")
+			}
+		}
 	}
 
-	// Get the rule file path
-	ruleFilePath := args[0]
+	// Use the ruleset name as the rule slug
+	ruleSlug := rs.Name
+
+	// Validate the slug format
+	if !isValidSlug(ownerSlug) || !isValidSlug(ruleSlug) {
+		return fmt.Errorf("invalid slug format: %s/%s", ownerSlug, ruleSlug)
+	}
+
+	// Find the main rule file to publish
+	// Look for index.md in the rules directory
+	var ruleFilePath string
+	if rulesPath != "" {
+		// If a path was specified, look for index.md in that directory
+		stat, err := os.Stat(rulesPath)
+		if err == nil && stat.IsDir() {
+			ruleFilePath = filepath.Join(rulesPath, "index.md")
+		}
+	} else {
+		// Look in current directory for index.md
+		ruleFilePath = "index.md"
+	}
+
+	// If index.md doesn't exist, look for any .md file in the rules directory
+	if _, err := os.Stat(ruleFilePath); os.IsNotExist(err) {
+		// Look for any .md file in the current directory
+		files, err := filepath.Glob("*.md")
+		if err == nil && len(files) > 0 {
+			ruleFilePath = files[0]
+		} else {
+			return fmt.Errorf("no rule file found to publish. Please create an index.md file or specify a rule file")
+		}
+	}
 
 	// Check if the file exists
 	if _, err := os.Stat(ruleFilePath); os.IsNotExist(err) {
@@ -81,11 +138,6 @@ func runPublishCommand(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to read rule file: %w", err)
 	}
 
-	// Create registry client
-	authConfig := auth.LoadAuthConfig()
-	client := registry.NewClient(cfg.RegistryURL)
-	client.SetAuthToken(authConfig.AccessToken)
-
 	// Publish the rule
 	color.Cyan("Publishing rule to %s/%s with visibility: %s", ownerSlug, ruleSlug, visibility)
 	err = client.PublishRule(ownerSlug, ruleSlug, string(content), visibility)
@@ -98,13 +150,28 @@ func runPublishCommand(cmd *cobra.Command, args []string) error {
 	return nil
 }
 
+// isValidSlug checks if a slug is valid (alphanumeric, hyphens, underscores only)
+func isValidSlug(slug string) bool {
+	if slug == "" {
+		return false
+	}
+	
+	// Check if slug contains only valid characters
+	for _, char := range slug {
+		if !((char >= 'a' && char <= 'z') || 
+			 (char >= 'A' && char <= 'Z') || 
+			 (char >= '0' && char <= '9') || 
+			 char == '-' || char == '_') {
+			return false
+		}
+	}
+	
+	return true
+}
+
 func init() {
 	rootCmd.AddCommand(publishCmd)
 
 	// Add flags
-	publishCmd.Flags().StringVar(&slug, "slug", "", "The organization/ruleset slug to publish to (required)")
 	publishCmd.Flags().StringVar(&visibility, "visibility", "public", "Set the visibility of the rule to 'public' or 'private'")
-
-	// Mark required flags
-	publishCmd.MarkFlagRequired("slug")
 }

docs/docs/index.md

@@ -58,16 +58,18 @@ To make your rule available to others, you can publish a markdown file using `ru
 
 ```bash
 rules login
-rules publish my-rule.md --slug my-username/my-rule
+rules publish
 ```
 
-This would make your rule available to download with `rules add my-username/my-rule`.
+This would make your rule available to download with `rules add <your-username>/<your-ruleset-name>`.
+
+The command automatically determines the slug from your `rules.json` file and your authenticated user information. Make sure you have a `rules.json` file in your current directory with a `name` field, and an `index.md` file containing your rule content.
 
 <!--
 You can also publish a folder of markdown files:
 
 ```bash
-rules publish ./my-rules --slug my-username/my-rules
+rules publish ./my-rules
 ``` -->
 
 ## Helping users use your rules

internal/registry/registry.go

@@ -40,6 +40,14 @@ type PublishRuleRequest struct {
 	Content    string `json:"content"`
 }
 
+// UserInfo represents user information from the registry
+type UserInfo struct {
+	ID       string `json:"id"`
+	Email    string `json:"email"`
+	Username string `json:"username"`
+	OrgSlug  string `json:"orgSlug"`
+}
+
 // NewClient creates a new registry client
 func NewClient(baseURL string) *Client {
 	return &Client{
@@ -312,3 +320,39 @@ func (c *Client) downloadFromGitHub(repoPath string, formatDir string) error {
 
 	return nil
 }
+
+// GetUserInfo fetches user information from the registry
+func (c *Client) GetUserInfo() (*UserInfo, error) {
+	if !c.IsLoggedIn {
+		return nil, fmt.Errorf("you must be logged in to get user information")
+	}
+	
+	url := fmt.Sprintf("%s/user", c.BaseURL)
+	
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.AuthToken))
+	utils.SetUserAgent(req)
+	
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get user info: %w", err)
+	}
+	defer resp.Body.Close()
+	
+	if resp.StatusCode != http.StatusOK {
+		bodyBytes, _ := ioutil.ReadAll(resp.Body)
+		return nil, fmt.Errorf("failed to get user info: status %d, response: %s", resp.StatusCode, string(bodyBytes))
+	}
+	
+	var userInfo UserInfo
+	if err := json.NewDecoder(resp.Body).Decode(&userInfo); err != nil {
+		return nil, fmt.Errorf("failed to decode user info: %w", err)
+	}
+	
+	return &userInfo, nil
+}

internal/ruleset/ruleset.go

@@ -3,6 +3,7 @@ package ruleset
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -128,4 +129,53 @@ func CreateRule(rule Rule, format, name string) error {
 	// Create the rule file
 	fileName := filepath.Join(ruleDir, name+".md")
 	return os.WriteFile(fileName, []byte(content), 0644)
+}
+
+// FindRuleSetFile looks for rules.json in the current directory or specified path
+func FindRuleSetFile(path string) (string, error) {
+	if path != "" {
+		// If path is specified, check if it's a directory or file
+		stat, err := os.Stat(path)
+		if err != nil {
+			return "", fmt.Errorf("path does not exist: %w", err)
+		}
+		
+		if stat.IsDir() {
+			// If it's a directory, look for rules.json inside it
+			rulesPath := filepath.Join(path, "rules.json")
+			if _, err := os.Stat(rulesPath); err == nil {
+				return rulesPath, nil
+			}
+			return "", fmt.Errorf("rules.json not found in directory: %s", path)
+		} else {
+			// If it's a file, check if it's rules.json
+			if filepath.Base(path) == "rules.json" {
+				return path, nil
+			}
+			return "", fmt.Errorf("specified file is not rules.json")
+		}
+	}
+	
+	// Look for rules.json in current directory
+	currentDir, err := os.Getwd()
+	if err != nil {
+		return "", fmt.Errorf("failed to get current directory: %w", err)
+	}
+	
+	rulesPath := filepath.Join(currentDir, "rules.json")
+	if _, err := os.Stat(rulesPath); err == nil {
+		return rulesPath, nil
+	}
+	
+	return "", fmt.Errorf("rules.json not found in current directory")
+}
+
+// LoadRuleSetFromPath loads a ruleset from the current directory or specified path
+func LoadRuleSetFromPath(path string) (*RuleSet, error) {
+	rulesPath, err := FindRuleSetFile(path)
+	if err != nil {
+		return nil, err
+	}
+	
+	return LoadRuleSet(rulesPath)
 }

spec/index.md

@@ -193,17 +193,21 @@ rules install --force  # Skip confirmation prompts
 Publishes a rule file to the registry.
 
 ```bash
-rules publish my-rule.md --slug my-org/my-rules
-rules publish my-rule.md --slug my-org/my-rules --visibility private
+rules publish                    # Publish from current directory
+rules publish ./my-rules         # Publish from specified directory
+rules publish --visibility private
 ```
 
 - **Args**:
-  - Path to the rule file to publish
+  - Optional path to directory containing rules.json (defaults to current directory)
 - **Flags**:
-  - `--slug`: The organization/ruleset slug to publish to (required)
   - `--visibility`: Set the visibility of the rule to "public" or "private" (default: "public")
 - **Behavior**:
-  - Reads the content of the specified rule file
+  - Reads the slug from rules.json in the current directory or specified path
+  - The slug is constructed as `{organization}/{ruleset-name}` where:
+    - `organization` is determined from the authenticated user's organization slug, username, or email prefix
+    - `ruleset-name` is the "name" field from rules.json
+  - Automatically finds the main rule file to publish (index.md or first .md file found)
   - Uses the registry API's POST endpoint to publish the rule
   - Requires user to be logged in (uses Bearer auth)
   - Sets the visibility of the published rule according to the flag

tests/golden_commands.txt

@@ -28,7 +28,7 @@ install|tests/golden/install/install.golden
 logout|tests/golden/logout/logout.golden
 
 # login
-login|tests/golden/login/login.golden
+# login|tests/golden/login/login.golden
 
 # publish
 publish|tests/golden/publish/publish.golden