feat: accept plain yaml/yml/json profiles in cloned repos and gists (#74)

* feat: fall back to plain yaml/yml/json when no *.raid.yaml at repo root

`raid profile add <git-url>` previously only picked up profile files
matching the *.raid.yaml convention (or profile.json). Single-file
gists and scratch repos that just contain `profile.yaml` or
`myprofile.yml` would clone successfully but then fail with
"No profile files found in repository".

When the primary patterns (profile.raid.yaml, *.raid.yaml/*.raid.yml,
profile.json) match nothing, fall back to any plain .yaml/.yml/.json
at the repo root. processProfileFiles validates each candidate against
the profile schema, so non-profile YAML in a repo root is still
rejected with a clear "Skipping … invalid profile" message rather
than misbehaving.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix: exit 1 when no profile candidate validated successfully

Copilot review feedback on #74: the new plain-yaml fallback in
findProfileFilesInDir can now match arbitrary root yamls (e.g.
docker-compose.yaml from a gist or scratch repo). Those candidates fail
schema validation in processProfileFiles and the function previously
returned exit 0 with "No new profiles found" — the same code path used
when "all profiles already exist", which masks a real failure and means
`raid profile add <url>` would falsely report success.

Differentiate the two cases:
- queued empty AND existingNames non-empty → "all already exist", exit 0
  (unchanged for the ergonomic re-run case).
- queued empty AND existingNames empty → "No valid profiles found",
  exit 1.

Also adds a regression test exercising exactly the gist-style scenario
flagged in the review: a cloned repo containing only docker-compose.yaml,
which now correctly exits 1.

Existing tests that assumed schema-invalid input was a soft success
(httpURL_invalidProfile, httpURL_unmarshalError, invalidProfileName)
updated to assert the new — and more correct — exit-1 behavior.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* test: cover the fallback loop's directory-skip branch

The plain-yaml fallback in findProfileFilesInDir skips subdirectories
(only files are profile candidates), but no existing test exercised
that branch — the codecov/patch check was flagging it as uncovered.
Real-world example: a scratch repo with docs/ and assets/ alongside a
profile.yaml at the root.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 8bitAlex

site/docs/usage/profile.mdx

@@ -36,18 +36,20 @@ Add a profile from a local file:
 raid profile add ./my-profile.yaml
 ```
 
-Add a profile from a git repository — raid shallow-clones it and imports `*.raid.yaml`, `*.raid.yml`, and `profile.json` files found at the root:
+Add a profile from a git repository — raid shallow-clones it and imports `*.raid.yaml`, `*.raid.yml`, and `profile.json` files found at the root. If none of those match, raid falls back to any plain `.yaml` / `.yml` / `.json` at the root, so a single-file gist (or scratch repo) with `profile.yaml` or `myprofile.yml` works without renaming:
 
 ```bash
 raid profile add https://github.com/my-org/raid-profiles
 raid profile add git@github.com:my-org/raid-profiles.git
+raid profile add https://gist.github.com/<user>/<id>     # gist with profile.yaml
 ```
 
-Add a profile from a raw file URL (HTTP/HTTPS URL ending in `.yaml`, `.yml`, or `.json`):
+Add a profile from a raw file URL (HTTP/HTTPS URL ending in `.yaml`, `.yml`, or `.json`) — handy for the gist "Raw" link, where the filename inside the gist doesn't matter:
 
 ```bash
 raid profile add https://example.com/team-profile.yaml
 raid profile add https://raw.githubusercontent.com/my-org/repo/main/team.raid.yaml
+raid profile add https://gist.githubusercontent.com/<user>/<id>/raw/<sha>/profile.yaml
 ```
 
 **URL type detection.** Raid picks the right strategy automatically:

site/docs/whats-new.mdx

@@ -9,6 +9,10 @@ description: Feature-by-feature release notes for Raid.
 
 User-visible changes per release, latest first. For full commit history see the [GitHub releases page](https://github.com/8bitalex/raid/releases).
 
+## 0.10.1 — upcoming
+
+**Plain-yaml profiles via `raid profile add <url>`.** When the URL points at a git repo (or a single-file gist) whose profile file isn't named with the `*.raid.yaml` convention — e.g. just `profile.yaml`, `myprofile.yml`, or `config.json` — raid now picks it up as a fallback after no `*.raid.yaml`/`profile.json` matches are found. Schema validation runs the same way, so non-profile YAML lying around in a repo root is still rejected with a clear "invalid profile" message. Makes ad-hoc gists usable without renaming the file.
+
 ## 0.10.0 — upcoming
 
 **Local-only repositories.** `url` is now optional on profile repository entries. Omit it for projects that aren't backed by a git remote — raid skips cloning and runs install tasks against the existing path. The path must already exist on disk; if it doesn't, raid surfaces a clear error instead of trying to `git clone ""`. `raid doctor` no longer flags a missing `.git` directory as a warning for local-only repos. Closes [#71](https://github.com/8bitAlex/raid/issues/71).

src/cmd/profile/fetch.go

@@ -139,6 +139,12 @@ func addProfilesFromHTTPURL(rawURL string) int {
 
 // findProfileFilesInDir returns profile YAML/JSON files found at the root of dir.
 // Priority: profile.raid.yaml/yml first, then any *.raid.yaml/yml, then profile.json.
+// Fallback for repositories that don't follow the *.raid.yaml convention
+// (single-file gists, scratch repos): if none of the above match, accept any
+// plain .yaml/.yml/.json at the root. processProfileFiles validates each
+// candidate against the profile schema, so non-profile YAML lying around
+// in a repo root produces a clear "Skipping … invalid profile" message
+// rather than incorrect behavior.
 func findProfileFilesInDir(dir string) []string {
 	seen := map[string]bool{}
 	var found []string
@@ -175,6 +181,18 @@ func findProfileFilesInDir(dir string) []string {
 
 	add("profile.json")
 
+	if len(found) == 0 {
+		for _, e := range entries {
+			if e.IsDir() {
+				continue
+			}
+			ext := strings.ToLower(filepath.Ext(e.Name()))
+			if ext == ".yaml" || ext == ".yml" || ext == ".json" {
+				add(e.Name())
+			}
+		}
+	}
+
 	return found
 }
 
@@ -222,6 +240,17 @@ func processProfileFiles(paths []string) int {
 	}
 
 	if len(queued) == 0 {
+		// Differentiate "all profiles already registered" (fine, exit 0)
+		// from "we found candidate files but none validated as profiles"
+		// (a real failure — exit 1 so callers and CI catch it). The
+		// fallback in findProfileFilesInDir can pull in plain root yamls
+		// like docker-compose.yaml from gists/scratch repos; without
+		// this branch `raid profile add <url>` would exit 0 even though
+		// nothing was imported.
+		if len(existingNames) == 0 {
+			fmt.Println("No valid profiles found")
+			return 1
+		}
 		fmt.Println("No new profiles found")
 		return 0
 	}

src/cmd/profile/fetch_test.go

@@ -143,13 +143,70 @@ func TestFindProfileFilesInDir_noDuplicates(t *testing.T) {
 	}
 }
 
-func TestFindProfileFilesInDir_noRaidYAML_noJSON(t *testing.T) {
+func TestFindProfileFilesInDir_plainYAMLFallback(t *testing.T) {
 	dir := t.TempDir()
-	// A plain .yaml file should not be picked up.
+	// Single-file gist scenario: a plain .yaml at the root, no *.raid.yaml.
+	// Should be picked up as a fallback.
 	writeRaidYAML(t, dir, "plain.yaml", "p")
 	got := findProfileFilesInDir(dir)
-	if len(got) != 0 {
-		t.Errorf("findProfileFilesInDir plain yaml: got %v, want none", got)
+	if len(got) != 1 || !strings.HasSuffix(got[0], "plain.yaml") {
+		t.Errorf("findProfileFilesInDir plain yaml fallback: got %v", got)
+	}
+}
+
+func TestFindProfileFilesInDir_plainYAMLNotPickedUpWhenRaidYAMLExists(t *testing.T) {
+	dir := t.TempDir()
+	// When a *.raid.yaml is present, plain .yaml/.yml siblings (e.g. CI
+	// configs, docker-compose files) must NOT be picked up — the fallback
+	// only kicks in when there are no primary matches.
+	writeRaidYAML(t, dir, "profile.raid.yaml", "p")
+	writeRaidYAML(t, dir, "docker-compose.yaml", "ignored")
+	writeRaidYAML(t, dir, "ci.yml", "ignored")
+	got := findProfileFilesInDir(dir)
+	if len(got) != 1 || !strings.HasSuffix(got[0], "profile.raid.yaml") {
+		t.Errorf("findProfileFilesInDir: got %v, want only profile.raid.yaml", got)
+	}
+}
+
+func TestFindProfileFilesInDir_multiplePlainYAMLFallback(t *testing.T) {
+	dir := t.TempDir()
+	// Multi-file gist: multiple plain yaml files, no *.raid.yaml. All are
+	// picked up; processProfileFiles will validate each one and skip those
+	// that aren't valid profiles.
+	writeRaidYAML(t, dir, "a.yaml", "a")
+	writeRaidYAML(t, dir, "b.yml", "b")
+	got := findProfileFilesInDir(dir)
+	if len(got) != 2 {
+		t.Errorf("findProfileFilesInDir multi plain: got %d files, want 2", len(got))
+	}
+}
+
+func TestFindProfileFilesInDir_plainJSONFallback(t *testing.T) {
+	dir := t.TempDir()
+	// Plain .json file (not literally named profile.json) — picked up via
+	// the same fallback so a gist with `myprofile.json` works.
+	path := filepath.Join(dir, "myprofile.json")
+	if err := os.WriteFile(path, []byte(`{"name":"j"}`), 0644); err != nil {
+		t.Fatal(err)
+	}
+	got := findProfileFilesInDir(dir)
+	if len(got) != 1 || !strings.HasSuffix(got[0], "myprofile.json") {
+		t.Errorf("findProfileFilesInDir plain json fallback: got %v", got)
+	}
+}
+
+func TestFindProfileFilesInDir_fallbackSkipsDirectories(t *testing.T) {
+	dir := t.TempDir()
+	// Subdirectory at the repo root must be skipped by the fallback loop —
+	// only files are considered profile candidates. Real-world example: a
+	// scratch repo with `docs/` and `assets/` plus a single profile.yaml.
+	if err := os.Mkdir(filepath.Join(dir, "docs"), 0755); err != nil {
+		t.Fatal(err)
+	}
+	writeRaidYAML(t, dir, "profile.yaml", "p")
+	got := findProfileFilesInDir(dir)
+	if len(got) != 1 || !strings.HasSuffix(got[0], "profile.yaml") {
+		t.Errorf("findProfileFilesInDir with subdir: got %v, want only profile.yaml", got)
 	}
 }
 
@@ -264,6 +321,40 @@ func TestRunAddProfile_gitURL_noProfiles(t *testing.T) {
 	}
 }
 
+// TestRunAddProfile_gitURL_onlyNonProfileYAML covers the regression
+// surface introduced by the plain-yaml fallback in findProfileFilesInDir.
+// A repo (or single-file gist) whose only root yaml/json files are
+// non-profile content (e.g. docker-compose.yaml, package.json) now gets
+// pulled in by the fallback, fails schema validation in
+// processProfileFiles, and must exit 1 with "No valid profiles found"
+// rather than misleadingly succeeding with "No new profiles found".
+func TestRunAddProfile_gitURL_onlyNonProfileYAML(t *testing.T) {
+	setupConfig(t)
+	defer saveFetchMocks()()
+
+	homeDir := t.TempDir()
+	getHomeDir = func() string { return homeDir }
+	detectGitURL = func(string) bool { return true }
+	gitCloneFunc = func(_, dir string) error {
+		// Plain non-profile yaml at the repo root — matches the fallback
+		// glob but fails schema validation.
+		return os.WriteFile(filepath.Join(dir, "docker-compose.yaml"),
+			[]byte("services:\n  web:\n    image: nginx\n"), 0644)
+	}
+
+	out := captureStdout(t, func() {
+		if code := runAddProfile("https://github.com/example/repo"); code != 1 {
+			t.Errorf("code = %d, want 1", code)
+		}
+	})
+	if !strings.Contains(out, "No valid profiles found") {
+		t.Errorf("got %q, want 'No valid profiles found'", out)
+	}
+	if !strings.Contains(out, "Skipping docker-compose.yaml") {
+		t.Errorf("got %q, want 'Skipping docker-compose.yaml' diagnostic", out)
+	}
+}
+
 func TestRunAddProfile_httpURL_success(t *testing.T) {
 	setupConfig(t)
 	defer saveFetchMocks()()
@@ -318,12 +409,16 @@ func TestRunAddProfile_httpURL_invalidProfile(t *testing.T) {
 	}
 
 	out := captureStdout(t, func() {
-		if code := runAddProfile("https://example.com/profile.yaml"); code != 0 {
-			t.Errorf("code = %d, want 0", code)
+		// Schema-invalid input is a real failure — exit 1, not 0. The
+		// previous "No new profiles found" exit-0 behavior masked
+		// failures (especially relevant now that the file-discovery
+		// fallback can pull in arbitrary plain yaml).
+		if code := runAddProfile("https://example.com/profile.yaml"); code != 1 {
+			t.Errorf("code = %d, want 1", code)
 		}
 	})
-	if !strings.Contains(out, "No new profiles found") {
-		t.Errorf("got %q, want 'No new profiles found'", out)
+	if !strings.Contains(out, "No valid profiles found") {
+		t.Errorf("got %q, want 'No valid profiles found'", out)
 	}
 }
 
@@ -342,12 +437,13 @@ func TestRunAddProfile_httpURL_unmarshalError(t *testing.T) {
 	proUnmarshal = func(string) ([]pro.Profile, error) { return nil, errMock }
 
 	out := captureStdout(t, func() {
-		if code := runAddProfile("https://example.com/profile.yaml"); code != 0 {
-			t.Errorf("code = %d, want 0", code)
+		// Unmarshal failures are real errors — exit 1.
+		if code := runAddProfile("https://example.com/profile.yaml"); code != 1 {
+			t.Errorf("code = %d, want 1", code)
 		}
 	})
-	if !strings.Contains(out, "No new profiles found") {
-		t.Errorf("got %q, want 'No new profiles found'", out)
+	if !strings.Contains(out, "No valid profiles found") {
+		t.Errorf("got %q, want 'No valid profiles found'", out)
 	}
 }
 
@@ -461,8 +557,9 @@ func TestRunAddProfile_invalidProfileName(t *testing.T) {
 	proContains = func(string) bool { return false }
 
 	out := captureStdout(t, func() {
-		if code := runAddProfile("https://example.com/profile.yaml"); code != 0 {
-			t.Errorf("code = %d, want 0", code)
+		// All profiles rejected by ValidateFileName → real failure, exit 1.
+		if code := runAddProfile("https://example.com/profile.yaml"); code != 1 {
+			t.Errorf("code = %d, want 1", code)
 		}
 	})
 	if !strings.Contains(out, "invalid name") {

src/resources/app.properties

@@ -1,2 +1,2 @@
-version=0.10.0-beta
+version=0.10.1-beta
 environment=development