add frontend-only workspace kind: scaffold frontend/ apps without Go backend, devops, or backend verify gate

Author: ehsannm

ronyup/README.MD

@@ -49,6 +49,8 @@ This copies the embedded workspace skeleton, initializes a `go.work`, and create
 
 Pass `--kind fullstack` to scaffold a `backend/` + `frontend/` split instead of a Go-only repo. The Go workspace (`go.work`, `cmd/service`, `pkg`, `feature`, `Makefile`, `.golangci.yml`) is created under `backend/`, while `devops/`, `docs/`, and the AI assistant config (`.ai/`, `.agents/`, `.cursor/`, `AGENTS.md`) stay at the root. In fullstack mode, run `setup feature` and `make`/`go` commands from the `backend/` directory.
 
+Pass `--kind frontend` to scaffold a frontend-only repo: a `frontend/` application plus shared AI assistant config and `docs/` at the root, with no Go workspace, `devops/`, or backend verify gate.
+
 ### Add a feature
 
 ```bash
@@ -123,7 +125,7 @@ Workspace flags:
 
 - `--repoDir`, `-r`: destination directory for the workspace.
 - `--appName`, `-a`: application name (default `myapp`).
-- `--kind`, `-k`: workspace kind, `backend` (default) or `fullstack`.
+- `--kind`, `-k`: workspace kind, `backend` (default), `fullstack`, or `frontend`.
 
 Feature flags:
 
@@ -214,7 +216,7 @@ Flags:
 ```
 -r, --repoDir string    destination directory for the setup (default "./my-repo")
 -a, --appName string    application name (default "myapp")
--k, --kind string       workspace kind: backend | fullstack (default "backend")
+-k, --kind string       workspace kind: backend | fullstack | frontend (default "backend")
 ```
 
 What it does:
@@ -226,6 +228,7 @@ What it does:
 Kinds:
 - `backend` (default): a Go-only workspace at `repoDir`.
 - `fullstack`: a `backend/` + `frontend/` split. The Go workspace is created under `backend/` (modules are prefixed with `backend/`, e.g. `github.com/you/repo/backend/cmd/service`), while `devops/`, `docs/`, and AI assistant config (`.ai/`, `.agents/`, `.cursor/`, `AGENTS.md`) stay at the root and are shared. Run `setup feature` from the `backend/` directory.
+- `frontend`: a frontend-only workspace — a `frontend/` application plus shared AI assistant config (`.ai/`, `.agents/`, `.cursor/`, `AGENTS.md`) and `docs/` at the root. No Go workspace, `devops/`, `Makefile`, or backend verify gate is created; only the frontend verify stop hook is installed.
 
 #### setup feature
 

ronyup/cmd/mcp/knowledge/resources/architecture/workspace-layout.md

@@ -1,7 +1,8 @@
-`ronyup setup workspace` supports two layouts via `--kind` (default `backend`):
+`ronyup setup workspace` supports three layouts via `--kind` (default `backend`):
 
 - **`backend`** — a Go-only workspace at the repository root.
 - **`fullstack`** — a `backend/` + `frontend/` split. The Go workspace is moved into `backend/`, while AI assistant config (`.ai/`, `.agents/`, `.cursor/`, `AGENTS.md`), `devops/`, and `docs/` stay at the repository root and are shared by both sides.
+- **`frontend`** — a frontend-only workspace: a `frontend/` application plus shared AI assistant config (`.ai/`, `.agents/`, `.cursor/`, `AGENTS.md`) and `docs/` at the repository root. There is **no** Go workspace, `devops/`, `Makefile`, or backend verify gate; only the frontend verify stop hook is installed.
 
 ## Backend layout (root of the Go workspace)
 
@@ -31,9 +32,9 @@ Each module under `feature/<name>/` (or `feature/<template>/<name>/` when groupe
 - In `backend` kind, modules are `<repoModule>/cmd/service`, `<repoModule>/feature/<name>`, etc.
 - In `fullstack` kind, the Go workspace is nested, so modules are `<repoModule>/backend/cmd/service`, `<repoModule>/backend/feature/<name>`, etc. Run `ronyup setup feature` (and `go`/`make` commands) from the `backend/` directory. `docs/design` still lives at the repository root, and the `scaffold_feature` design gate resolves it from the parent of `backend/` automatically.
 
-## Frontend (fullstack only)
+## Frontend (`fullstack` and `frontend` kinds)
 
-- `frontend/` — holds the web/mobile application(s). It is framework-agnostic by default (a placeholder `README.MD`); initialize it with the stack of your choice (React/Vite, Next.js, SvelteKit, …) and call the backend via its OpenAPI spec at `/docs`.
+- `frontend/` — holds the web/mobile application(s) at the repository root. It is framework-agnostic by default (a placeholder `README.MD`); initialize it with the stack of your choice (React/Vite, Next.js, SvelteKit, …). In `fullstack` workspaces it calls the backend via its OpenAPI spec at `/docs`; in `frontend`-only workspaces it talks to external services over their HTTP/OpenAPI APIs.
 - **One app vs. many — always clarify first.** Do not assume a single frontend app. Before creating or editing anything under `frontend/`, ask the user whether there is one app or multiple.
   - Single app: code may live directly under `frontend/`.
   - Multiple apps: give each app its own directory, `frontend/<app-name>/` (e.g. `frontend/admin/`, `frontend/web/`). Confirm which app a change targets, and the app name/stack when initializing a new one, before proceeding.

ronyup/cmd/mcp/knowledge/resources/tools/scaffold_workspace.md

@@ -10,6 +10,7 @@ The tool runs `ronyup setup workspace` with the provided `path` as the working d
 
 - **`backend`** (default) — a Go-only workspace at `path`, containing `go.work`, `cmd/service/`, `pkg/i18n/`, an empty `feature/` tree, `devops/`, `docs/`, and a `.ai/mcp/mcp.json` for IDE integration.
 - **`fullstack`** — a `backend/` + `frontend/` split. The Go workspace (`go.work`, `cmd/service/`, `pkg/`, `feature/`, `Makefile`, `.golangci.yml`) is created under `backend/`, while `devops/`, `docs/`, and the AI assistant config (`.ai/`, `.agents/`, `.cursor/`, `AGENTS.md`) stay at the root and are shared. A framework-agnostic `frontend/` placeholder is created for the web/mobile app.
+- **`frontend`** — a frontend-only workspace: a framework-agnostic `frontend/` placeholder plus shared AI assistant config (`.ai/`, `.agents/`, `.cursor/`, `AGENTS.md`) and `docs/` at the root. No Go workspace, `devops/`, `Makefile`, or backend verify gate is created; only the frontend verify stop hook is installed.
 
 For `fullstack`, Go module paths are prefixed with `backend/` (e.g. `<repoModule>/backend/cmd/service`). Run `scaffold_feature` (and `go`/`make` commands) against the `backend/` directory; the design gate still finds `docs/design` at the repository root.
 

ronyup/cmd/mcp/tools/scaffold/scaffold.go

@@ -33,11 +33,12 @@ func registerSetupWorkspace(srv *mcpsdk.Server, runner Runner, executable string
 				},
 				"kind": map[string]any{
 					"type": "string",
-					"description": "Workspace layout: 'backend' (Go-only at the root, default) or " +
+					"description": "Workspace layout: 'backend' (Go-only at the root, default), " +
 						"'fullstack' (backend/ + frontend/ split, with the Go workspace under backend/ " +
-						"and devops/, docs/ and AI config kept at the root).",
+						"and devops/, docs/ and AI config kept at the root), or 'frontend' (frontend/ app " +
+						"plus shared AI config and docs/ at the root, with no Go workspace).",
 					"default": "backend",
-					"enum":    []string{"backend", "fullstack"},
+					"enum":    []string{"backend", "fullstack", "frontend"},
 				},
 				"skills": map[string]any{
 					"type": "array",

ronyup/cmd/setup/interactive.go

@@ -93,10 +93,11 @@ func runWorkspaceInteractive(cmd *cobra.Command) error {
 				Value(&opt.ApplicationName),
 			huh.NewSelect[string]().
 				Title("Workspace Kind").
-				Description("Backend only, or backend + frontend split").
+				Description("Backend only, backend + frontend split, or frontend only").
 				Options(
 					huh.NewOption("Backend only", KindBackend),
 					huh.NewOption("Backend + Frontend", KindFullstack),
+					huh.NewOption("Frontend only", KindFrontend),
 				).
 				Value(&opt.Kind),
 		),

ronyup/cmd/setup/setup.go

@@ -22,8 +22,17 @@ const (
 	// KindFullstack scaffolds a backend/ + frontend/ split: the Go workspace
 	// is moved into backend/ while AI config, devops/ and docs/ stay at root.
 	KindFullstack = "fullstack"
+	// KindFrontend scaffolds a frontend-only workspace: a frontend/ application
+	// plus shared AI config and docs/ at the root, with no Go workspace.
+	KindFrontend = "frontend"
 )
 
+// hasBackend reports whether the workspace kind includes a Go backend.
+func hasBackend(kind string) bool { return kind != KindFrontend }
+
+// hasFrontend reports whether the workspace kind includes a frontend app.
+func hasFrontend(kind string) bool { return kind != KindBackend }
+
 // backendDir is the subdirectory that holds the Go workspace for fullstack
 // scaffolds.
 const backendDir = "backend"
@@ -133,7 +142,7 @@ func init() {
 		"kind",
 		"k",
 		KindBackend,
-		"workspace kind: backend | fullstack",
+		"workspace kind: backend | fullstack | frontend",
 	)
 	workspaceFlagSet.StringSliceVarP(
 		&opt.Skills,
@@ -146,7 +155,7 @@ func init() {
 	_ = CmdSetupWorkspace.RegisterFlagCompletionFunc(
 		"kind",
 		func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-			return []string{KindBackend, KindFullstack}, cobra.ShellCompDirectiveNoFileComp
+			return []string{KindBackend, KindFullstack, KindFrontend}, cobra.ShellCompDirectiveNoFileComp
 		},
 	)
 
@@ -212,8 +221,13 @@ func runWorkspace(cmd *cobra.Command) error {
 		opt.Kind = KindBackend
 	}
 
-	if opt.Kind != KindBackend && opt.Kind != KindFullstack {
-		return fmt.Errorf("invalid workspace kind %q: must be %q or %q", opt.Kind, KindBackend, KindFullstack)
+	switch opt.Kind {
+	case KindBackend, KindFullstack, KindFrontend:
+	default:
+		return fmt.Errorf(
+			"invalid workspace kind %q: must be %q, %q or %q",
+			opt.Kind, KindBackend, KindFullstack, KindFrontend,
+		)
 	}
 
 	resolved, err := resolveSkillSelection(opt.Skills, opt.Kind)
@@ -253,15 +267,25 @@ func goModulePrefix() string {
 	return base
 }
 
-// workspaceDestMapper routes skeleton entries for fullstack scaffolds: AI
-// config, devops/ and docs/ stay at the repository root while the Go workspace
-// is placed under backend/. For backend scaffolds it returns nil (default
-// behaviour copies everything to the repo root).
+// workspaceDestMapper routes skeleton entries by workspace kind:
+//   - fullstack: AI config, devops/ and docs/ stay at the repository root while
+//     the Go workspace is placed under backend/.
+//   - frontend: only shared AI config and docs/ are copied to the root; the
+//     entire Go workspace (cmd/, pkg/, feature/, Makefile, .golangci.yml,
+//     verify.sh) and the backend stop hook are skipped.
+//   - backend: returns nil (default behaviour copies everything to the root).
 func workspaceDestMapper(repoRoot string) func(string) (string, bool) {
-	if opt.Kind != KindFullstack {
+	switch opt.Kind {
+	case KindFullstack:
+		return fullstackDestMapper(repoRoot)
+	case KindFrontend:
+		return frontendDestMapper(repoRoot)
+	default:
 		return nil
 	}
+}
 
+func fullstackDestMapper(repoRoot string) func(string) (string, bool) {
 	rootLevel := map[string]bool{
 		".cursor":   true,
 		".agents":   true,
@@ -276,22 +300,53 @@ func workspaceDestMapper(repoRoot string) func(string) (string, bool) {
 			return repoRoot, false
 		}
 
-		top := relPath
-		if before, _, ok := strings.Cut(relPath, "/"); ok {
-			top = before
+		if rootLevel[topSegment(relPath)] {
+			return filepath.Join(repoRoot, relPath), false
 		}
 
-		// Normalize the template suffix so e.g. "AGENTS.mdtmpl" matches.
-		top = strings.TrimSuffix(top, "tmpl")
+		return filepath.Join(repoRoot, backendDir, relPath), false
+	}
+}
 
-		if rootLevel[top] {
-			return filepath.Join(repoRoot, relPath), false
+func frontendDestMapper(repoRoot string) func(string) (string, bool) {
+	rootLevel := map[string]bool{
+		".cursor":   true,
+		".agents":   true,
+		".ai":       true,
+		"docs":      true,
+		"AGENTS.md": true,
+	}
+
+	return func(relPath string) (string, bool) {
+		if relPath == "" {
+			return repoRoot, false
 		}
 
-		return filepath.Join(repoRoot, backendDir, relPath), false
+		// Skip the entire Go workspace; keep only shared AI config and docs/.
+		if !rootLevel[topSegment(relPath)] {
+			return "", true
+		}
+
+		// The backend verify stop hook is irrelevant without a Go workspace.
+		if strings.HasSuffix(filepath.ToSlash(relPath), "hooks/backend-verify.sh") {
+			return "", true
+		}
+
+		return filepath.Join(repoRoot, relPath), false
 	}
 }
 
+// topSegment returns the first path segment, with any "tmpl" template suffix
+// stripped so e.g. "AGENTS.mdtmpl" matches "AGENTS.md".
+func topSegment(relPath string) string {
+	top := relPath
+	if before, _, ok := strings.Cut(relPath, "/"); ok {
+		top = before
+	}
+
+	return strings.TrimSuffix(top, "tmpl")
+}
+
 func createWorkspace(_ context.Context) error {
 	// get the absolute path to the output directory
 	repoPath, err := filepath.Abs(opt.RepositoryRootDir)
@@ -335,8 +390,11 @@ func copyWorkspaceTemplate(cmd *cobra.Command) {
 		},
 	))
 
-	if opt.Kind == KindFullstack {
+	if hasFrontend(opt.Kind) {
 		copyFrontendTemplate(cmd, repoRoot, templateInput)
+	}
+
+	if opt.Kind == KindFullstack {
 		fixupBackendDevopsPath(cmd, repoRoot)
 	}
 
@@ -347,22 +405,25 @@ func copyWorkspaceTemplate(cmd *cobra.Command) {
 
 	cmd.Println("Workspace created successfully")
 
-	goRoot := filepath.Join(repoRoot, goRootRel())
-	modulePrefix := goModulePrefix()
-
-	packages := []string{"pkg/i18n", "cmd/service"}
-	p := z.RunCmdParams{Dir: goRoot}
-	z.RunCmd(cmd.Context(), p, "go", "work", "init")
-
-	for _, pkg := range packages {
-		p = z.RunCmdParams{Dir: filepath.Join(goRoot, pkg)}
-		z.RunCmd(cmd.Context(), p, "go", "mod", "init", path.Join(modulePrefix, pkg))
-		z.RunCmd(cmd.Context(), p, "go", "mod", "edit", "-go=1.25")
-		z.RunCmd(cmd.Context(), p, "go", "mod", "tidy", "-e")
-		z.RunCmd(cmd.Context(), p, "go", "work", "use", ".")
+	// Frontend-only workspaces have no Go workspace to initialize.
+	if hasBackend(opt.Kind) {
+		goRoot := filepath.Join(repoRoot, goRootRel())
+		modulePrefix := goModulePrefix()
+
+		packages := []string{"pkg/i18n", "cmd/service"}
+		p := z.RunCmdParams{Dir: goRoot}
+		z.RunCmd(cmd.Context(), p, "go", "work", "init")
+
+		for _, pkg := range packages {
+			p = z.RunCmdParams{Dir: filepath.Join(goRoot, pkg)}
+			z.RunCmd(cmd.Context(), p, "go", "mod", "init", path.Join(modulePrefix, pkg))
+			z.RunCmd(cmd.Context(), p, "go", "mod", "edit", "-go=1.25")
+			z.RunCmd(cmd.Context(), p, "go", "mod", "tidy", "-e")
+			z.RunCmd(cmd.Context(), p, "go", "work", "use", ".")
+		}
 	}
 
-	p = z.RunCmdParams{Dir: repoRoot}
+	p := z.RunCmdParams{Dir: repoRoot}
 
 	isGitRepo, err := isGitRepository(repoRoot)
 	if err == nil && !isGitRepo {

ronyup/cmd/setup/setup_workspace_integration_test.go

@@ -189,6 +189,104 @@ func TestSetupWorkspaceCommand_FullstackLayout(t *testing.T) {
 	}
 }
 
+func TestSetupWorkspaceCommand_FrontendOnlyLayout(t *testing.T) {
+	tmpDir := t.TempDir()
+	repoDir := "fe-repo"
+	repoModule := "github.com/example/fe-repo"
+
+	stubBinDir := filepath.Join(tmpDir, "bin")
+	if err := os.MkdirAll(stubBinDir, 0o755); err != nil {
+		t.Fatalf("MkdirAll(stub bin) unexpected error: %v", err)
+	}
+
+	if err := writeExecutable(filepath.Join(stubBinDir, "go"), "#!/bin/sh\nexit 0\n"); err != nil {
+		t.Fatalf("writeExecutable(go) unexpected error: %v", err)
+	}
+
+	if err := writeExecutable(filepath.Join(stubBinDir, "git"), "#!/bin/sh\nexit 0\n"); err != nil {
+		t.Fatalf("writeExecutable(git) unexpected error: %v", err)
+	}
+
+	t.Setenv("PATH", stubBinDir+string(os.PathListSeparator)+os.Getenv("PATH"))
+
+	oldOpt := opt
+	t.Cleanup(func() {
+		opt = oldOpt
+	})
+
+	oldWD, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("Getwd() unexpected error: %v", err)
+	}
+	if err := os.Chdir(tmpDir); err != nil {
+		t.Fatalf("Chdir(tmpDir) unexpected error: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = os.Chdir(oldWD)
+	})
+
+	opt.RepositoryRootDir = repoDir
+	opt.RepositoryGoModule = repoModule
+	opt.ApplicationName = "demo"
+	opt.Kind = KindFrontend
+
+	Cmd.SetOut(os.Stdout)
+	Cmd.SetErr(os.Stderr)
+	Cmd.SetArgs([]string{"workspace"})
+
+	if err := Cmd.Execute(); err != nil {
+		t.Fatalf("Cmd.Execute() unexpected error: %v", err)
+	}
+
+	root := filepath.Join(tmpDir, repoDir)
+
+	// Frontend app, shared AI config, docs/, and the frontend stop hook exist.
+	for _, rel := range []string{
+		"frontend/README.MD", "frontend/verify.sh", "frontend/Makefile",
+		"docs", "AGENTS.md", ".ai/mcp/mcp.json",
+		".cursor/hooks.json", ".cursor/hooks/frontend-verify.sh",
+		".agents/skills/frontend-design",
+	} {
+		if _, err := os.Stat(filepath.Join(root, rel)); err != nil {
+			t.Fatalf("expected %s in frontend-only workspace: %v", rel, err)
+		}
+	}
+
+	// The Go workspace and backend-only artifacts must NOT be scaffolded.
+	for _, rel := range []string{
+		"cmd", "feature", "pkg", "Makefile", "verify.sh", ".golangci.yml",
+		"backend", ".cursor/hooks/backend-verify.sh", ".agents/skills/go-modern",
+	} {
+		if _, err := os.Stat(filepath.Join(root, rel)); !os.IsNotExist(err) {
+			t.Fatalf("did not expect %s in frontend-only workspace (err=%v)", rel, err)
+		}
+	}
+
+	// Stop hook wires only the frontend verify gate.
+	hooks, err := os.ReadFile(filepath.Join(root, ".cursor", "hooks.json"))
+	if err != nil {
+		t.Fatalf("ReadFile(.cursor/hooks.json) unexpected error: %v", err)
+	}
+	if !strings.Contains(string(hooks), "frontend-verify.sh") {
+		t.Fatalf("frontend-only hooks.json should register the frontend stop hook, got:\n%s", hooks)
+	}
+	if strings.Contains(string(hooks), "backend-verify.sh") {
+		t.Fatalf("frontend-only hooks.json should not register the backend stop hook, got:\n%s", hooks)
+	}
+
+	// AGENTS.md renders frontend-only guidance and drops backend sections.
+	agents, err := os.ReadFile(filepath.Join(root, "AGENTS.md"))
+	if err != nil {
+		t.Fatalf("ReadFile(AGENTS.md) unexpected error: %v", err)
+	}
+	if !strings.Contains(string(agents), "Frontend-only project") {
+		t.Fatalf("AGENTS.md should render frontend-only guidance, got:\n%s", agents)
+	}
+	if strings.Contains(string(agents), "## Package Selection (mandatory)") {
+		t.Fatalf("frontend-only AGENTS.md should not include the backend package-selection section, got:\n%s", agents)
+	}
+}
+
 func writeExecutable(path, content string) error {
 	if err := os.WriteFile(path, []byte(content), 0o755); err != nil {
 		return err