Merge branch 'main' into adopt

Author: runkids

CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## [0.20.15] - 2026-06-14
+
+### Bug Fixes
+
+- **Git branch refreshes now fail visibly when fetch fails** — the dashboard no longer serves stale remote branches or continues a checkout after `git fetch` fails. Branch listing and checkout requests now report the fetch failure so users can fix connectivity, authentication, or remote problems before switching branches.
+- **Source URL edits keep metadata and remotes in sync** — updating a tracked skill or agent source now updates the Git remote before saving metadata. If the remote update fails, the API returns an error and leaves the existing source metadata unchanged instead of reporting success with an old on-disk remote.
+- **Target removal preserves config when cleanup fails** — removing a target from the dashboard now stops if Skillshare cannot inspect the target, remove the target symlink, remove the target manifest, or clean managed symlinks. The target remains configured so users can fix the filesystem issue and retry instead of losing the target entry.
+- **Version checks handle release tag formats correctly** — update checks now accept versions with a leading `v` prefix while still rejecting malformed version segments. Local metadata builds only advertise a release version when built from a clean exact tag; non-release builds stay in `dev` mode so update checks do not compare against commit-describe strings.
+- **JSON-mode automation stays clean during cleanup warnings** — temporary Git clone cleanup failures are still logged for human-readable flows, but cleanup warnings no longer leak into `--json` stderr output.
+- **Skill linting reports rule load failures instead of panicking** — malformed embedded lint rules now return explicit errors through analysis/discovery paths, and repeated lint runs keep the load error instead of losing it after the first attempt.
+- **Audit finding severity dots are vertically centered** — severity indicators in the dashboard Audit findings list now align with their badges and messages.
+
+## [0.20.14] - 2026-06-13
+
+### Bug Fixes
+
+- **Push failures redact token-auth URLs without losing diagnostics** — failed Git push flows now sanitize credential-bearing error output before it reaches CLI/API/UI callers, while still preserving useful Git and pre-push hook diagnostics. Refs: #214.
+
+## [0.20.13] - 2026-06-11
+
+### New Features
+
+#### Web Dashboard
+
+- **Rehydrate missing tracked repos from the dashboard** — the Updates page now shows a warning banner listing tracked repos declared in `.metadata.json` whose clone directories are missing on disk, with a one-click **Rehydrate** button that re-clones them from metadata. The Dashboard's **Update All** also warns about missing repos and points to rehydrate, instead of reporting that there is nothing to update. Refs: #212.
+
+### Bug Fixes
+
+- **`update --all` reports missing tracked repos in batch and project mode** — reporting a missing tracked repo previously only worked when it was the single update target; when `update --all` covered multiple items (the common case) the batch path skipped missing repos silently, and project mode (`-p`) never detected them at all. Both now surface each missing repo with a warning and a one-shot rehydrate hint:
+  ```bash
+  skillshare update --all          # ! _team-skills  clone directory absent
+  skillshare install               # rehydrate from metadata
+  ```
+  `update --all --json` now carries an aggregated `missing_tracked_repos` summary (names + hint), and the per-item error is the concise `clone directory absent`. Refs: #212.
+
 ## [0.20.12] - 2026-06-11
 
 ### New Features

cmd/skillshare/json_output.go

@@ -3,6 +3,8 @@ package main
 import (
 	"encoding/json"
 	"fmt"
+	"io"
+	"log/slog"
 	"os"
 	"reflect"
 	"slices"
@@ -80,9 +82,10 @@ func (s *jsonUISuppressor) Flush() {
 }
 
 // suppressUIToDevnull temporarily redirects os.Stdout and the progress
-// writer to /dev/null so that handler functions using fmt.Printf / ui.*
-// produce zero visible output.  This keeps --json output clean even when
-// stdout and stderr share the same terminal (e.g. docker exec).
+// writer to /dev/null and silences slog so that handler functions using
+// fmt.Printf / ui.* / slog.* produce zero visible output.  This keeps --json
+// output clean even when stdout and stderr share the same terminal (e.g.
+// docker exec).
 // Returns a restore function that MUST be called before writing JSON.
 func suppressUIToDevnull() func() {
 	devnull, err := os.OpenFile(os.DevNull, os.O_WRONLY, 0)
@@ -97,10 +100,14 @@ func suppressUIToDevnull() func() {
 	ui.SetProgressWriter(devnull)
 	ui.SuppressProgress()
 
+	prevLogger := slog.Default()
+	slog.SetDefault(slog.New(slog.NewTextHandler(io.Discard, nil)))
+
 	return func() {
 		os.Stdout = origStdout
 		ui.SetProgressWriter(prevProgress)
 		ui.RestoreProgress()
+		slog.SetDefault(prevLogger)
 		if devnull != os.Stderr {
 			devnull.Close()
 		}

cmd/skillshare/json_output_test.go

@@ -5,7 +5,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
+	"strings"
 	"testing"
 )
 
@@ -90,3 +92,39 @@ func TestWriteJSONErrorIsWrappedWithErrorsAs(t *testing.T) {
 		t.Fatal("expected wrapped error unwrap chain to include jsonSilentError")
 	}
 }
+
+func TestJSONUISuppressorSuppressesSlogUntilFlush(t *testing.T) {
+	tmpFile, err := os.CreateTemp("", "skillshare-json-stderr-")
+	if err != nil {
+		t.Fatalf("creating temp file: %v", err)
+	}
+	t.Cleanup(func() { os.Remove(tmpFile.Name()) })
+
+	oldStderr := os.Stderr
+	os.Stderr = tmpFile
+	t.Cleanup(func() { os.Stderr = oldStderr })
+
+	oldLogger := slog.Default()
+	slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelWarn})))
+	t.Cleanup(func() { slog.SetDefault(oldLogger) })
+
+	suppressor := newJSONUISuppressor(true)
+	slog.Warn("structured cleanup warning")
+	suppressor.Flush()
+	slog.Warn("restored warning")
+
+	if err := tmpFile.Close(); err != nil {
+		t.Fatalf("closing temp file: %v", err)
+	}
+	data, err := os.ReadFile(tmpFile.Name())
+	if err != nil {
+		t.Fatalf("reading captured stderr: %v", err)
+	}
+	got := string(data)
+	if strings.Contains(got, "structured cleanup warning") {
+		t.Fatalf("structured-mode slog warning leaked to stderr: %q", got)
+	}
+	if !strings.Contains(got, "restored warning") {
+		t.Fatalf("expected logger to be restored after Flush, got: %q", got)
+	}
+}

cmd/skillshare/tracked_metadata.go

@@ -5,8 +5,34 @@ import (
 	"os"
 )
 
+// missingTrackedRepoShortReason is the concise per-item reason used in summarized
+// output (JSON items, UI). The full rehydration hint is surfaced once via
+// missingTrackedRepoHint instead of being repeated on every item.
+const missingTrackedRepoShortReason = "clone directory absent"
+
+// missingTrackedRepoHint is the one-shot recovery instruction for missing
+// tracked repos, shown alongside the summarized list.
+func missingTrackedRepoHint() string {
+	return "Run 'skillshare install' to rehydrate tracked repositories"
+}
+
 func missingTrackedRepoMessage(name string) string {
-	return fmt.Sprintf("tracked repository clone is missing: %s (metadata exists but directory is absent). Run 'skillshare install' to rehydrate tracked repositories.", name)
+	return fmt.Sprintf("tracked repository clone is missing: %s (metadata exists but directory is absent). %s.", name, missingTrackedRepoHint())
+}
+
+// missingTrackedRepoResult returns a skipped updateResult for a tracked repo
+// whose clone directory is absent on disk, and true. If the directory exists it
+// returns the zero value and false. Shared by the global and project single-target
+// update paths so both report missing repos consistently (issue #212).
+func missingTrackedRepoResult(t updateTarget) (updateResult, bool) {
+	if _, err := os.Stat(t.path); os.IsNotExist(err) {
+		return updateResult{
+			skipped:             1,
+			items:               []updateJSONItem{{Name: t.name, Type: "repo", Status: "skipped", Error: missingTrackedRepoShortReason}},
+			missingTrackedRepos: []string{t.name},
+		}, true
+	}
+	return updateResult{}, false
 }
 
 func updateTrackedRepoErrorMessage(target updateTarget, err error) string {

cmd/skillshare/update.go

@@ -31,13 +31,22 @@ type updateOptions struct {
 
 // updateJSONOutput is the JSON representation for update --json output.
 type updateJSONOutput struct {
-	Updated        int              `json:"updated"`
-	Skipped        int              `json:"skipped"`
-	SecurityFailed int              `json:"security_failed"`
-	Pruned         int              `json:"pruned"`
-	DryRun         bool             `json:"dry_run"`
-	Duration       string           `json:"duration"`
-	Items          []updateJSONItem `json:"items"`
+	Updated             int                         `json:"updated"`
+	Skipped             int                         `json:"skipped"`
+	SecurityFailed      int                         `json:"security_failed"`
+	Pruned              int                         `json:"pruned"`
+	DryRun              bool                        `json:"dry_run"`
+	Duration            string                      `json:"duration"`
+	Items               []updateJSONItem            `json:"items"`
+	MissingTrackedRepos *missingTrackedReposSummary `json:"missing_tracked_repos,omitempty"`
+}
+
+// missingTrackedReposSummary aggregates tracked repos declared in metadata whose
+// clone directories are absent on disk, so the per-item error stays concise while
+// the recovery hint is surfaced once. See issue #212.
+type missingTrackedReposSummary struct {
+	Names []string `json:"names"`
+	Hint  string   `json:"hint"`
 }
 
 type updateJSONItem struct {
@@ -380,13 +389,8 @@ func cmdUpdate(args []string) error {
 		var r updateResult
 		var updateErr error
 		if t.isRepo {
-			if opts.all {
-				if _, statErr := os.Stat(t.path); os.IsNotExist(statErr) {
-					r.skipped = 1
-					r.items = append(r.items, updateJSONItem{Name: t.name, Type: "repo", Status: "skipped", Error: missingTrackedRepoMessage(t.name)})
-				} else {
-					r, updateErr = updateTrackedRepo(uc, t.name)
-				}
+			if mr, missing := missingTrackedRepoResult(t); opts.all && missing {
+				r = mr
 			} else {
 				r, updateErr = updateTrackedRepo(uc, t.name)
 			}
@@ -404,6 +408,7 @@ func cmdUpdate(args []string) error {
 		if opts.jsonOutput {
 			return jsonWriteResult(&r, updateErr)
 		}
+		displayMissingTrackedReposWarning(r.missingTrackedRepos)
 		return updateErr
 	}
 
@@ -444,6 +449,12 @@ func updateOutputJSON(result *updateResult, dryRun bool, start time.Time, update
 		output.SecurityFailed = result.securityFailed
 		output.Pruned = result.pruned
 		output.Items = result.items
+		if len(result.missingTrackedRepos) > 0 {
+			output.MissingTrackedRepos = &missingTrackedReposSummary{
+				Names: result.missingTrackedRepos,
+				Hint:  missingTrackedRepoHint(),
+			}
+		}
 	}
 	return writeJSONResult(&output, updateErr)
 }

cmd/skillshare/update_audit_render.go

@@ -11,11 +11,12 @@ import (
 
 // updateResult tracks the result of an update operation
 type updateResult struct {
-	updated        int
-	skipped        int
-	securityFailed int
-	pruned         int
-	items          []updateJSONItem
+	updated             int
+	skipped             int
+	securityFailed      int
+	pruned              int
+	items               []updateJSONItem
+	missingTrackedRepos []string // names of tracked repos declared in metadata but absent on disk
 }
 
 // batchBlockedEntry records a skill that was blocked by security audit during batch update.
@@ -232,3 +233,17 @@ func displayStaleWarning(stale []string) {
 	}
 	ui.Info("Run with --prune to remove stale skills")
 }
+
+// displayMissingTrackedReposWarning warns about tracked repos declared in
+// metadata whose clone directories are absent on disk (issue #212).
+func displayMissingTrackedReposWarning(missing []string) {
+	if len(missing) == 0 {
+		return
+	}
+	fmt.Println()
+	ui.Warning("%d tracked repo(s) declared in metadata but missing on disk:", len(missing))
+	for _, name := range missing {
+		ui.ListItem("warning", name, missingTrackedRepoShortReason)
+	}
+	ui.Info("%s", missingTrackedRepoHint())
+}

cmd/skillshare/update_batch.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"os"
 	"strings"
 	"time"
 
@@ -61,6 +62,7 @@ func executeBatchUpdate(uc *updateContext, targets []updateTarget) (updateResult
 	var blockedEntries []batchBlockedEntry
 	var staleNames []string
 	var prunedNames []string
+	var missingRepoNames []string
 
 	// Group skills by RepoURL to optimize updates
 	repoGroups := make(map[string][]updateTarget)
@@ -105,6 +107,15 @@ func executeBatchUpdate(uc *updateContext, targets []updateTarget) (updateResult
 	}
 	for _, t := range trackedRepos {
 		progressBar.UpdateTitle(fmt.Sprintf("Updating %s", t.name))
+		// Tracked repo declared in metadata but clone dir is absent (issue #212):
+		// surface it instead of silently skipping (mirrors the single-target path).
+		if _, statErr := os.Stat(t.path); os.IsNotExist(statErr) {
+			result.skipped++
+			missingRepoNames = append(missingRepoNames, t.name)
+			result.items = append(result.items, updateJSONItem{Name: t.name, Type: "repo", Status: "skipped", Error: missingTrackedRepoShortReason})
+			progressBar.Increment()
+			continue
+		}
 		updated, auditResult, err := updateTrackedRepoQuick(uc, t.path)
 		if err != nil {
 			if isSecurityError(err) {
@@ -125,6 +136,7 @@ func executeBatchUpdate(uc *updateContext, targets []updateTarget) (updateResult
 		}
 		progressBar.Increment()
 	}
+	result.missingTrackedRepos = missingRepoNames
 
 	// Phase 2: grouped skills (one clone per repo)
 	if len(repoGroups) > 0 {
@@ -276,6 +288,7 @@ func executeBatchUpdate(uc *updateContext, targets []updateTarget) (updateResult
 		displayUpdateBlockedSection(blockedEntries)
 		displayPrunedSection(prunedNames)
 		displayStaleWarning(staleNames)
+		displayMissingTrackedReposWarning(missingRepoNames)
 		displayUpdateAuditResults(auditEntries, uc.opts.auditVerbose)
 		ui.UpdateSummary(ui.UpdateStats{
 			Updated:        result.updated,

cmd/skillshare/update_project.go

@@ -230,6 +230,20 @@ func updateAllProjectSkills(uc *updateContext) (*updateResult, error) {
 		return nil, fmt.Errorf("failed to scan skills: %w", err)
 	}
 
+	// Tracked repos declared in metadata but absent on disk (issue #212):
+	// surface them instead of silently ignoring (mirrors global --all).
+	existing := make(map[string]bool, len(targets))
+	for _, t := range targets {
+		existing[t.name] = true
+	}
+	missingRepos, _ := install.GetMissingTrackedRepos(uc.sourcePath)
+	for _, repo := range missingRepos {
+		if !existing[repo.Name] {
+			existing[repo.Name] = true
+			targets = append(targets, updateTarget{name: repo.Name, path: filepath.Join(uc.sourcePath, filepath.FromSlash(repo.Name)), isRepo: true})
+		}
+	}
+
 	var repoCount, skillCount int
 	for _, t := range targets {
 		if t.isRepo {
@@ -252,7 +266,12 @@ func updateAllProjectSkills(uc *updateContext) (*updateResult, error) {
 		var r updateResult
 		var updateErr error
 		if t.isRepo {
-			r, updateErr = updateTrackedRepo(uc, t.name)
+			if mr, missing := missingTrackedRepoResult(t); missing {
+				r = mr
+				displayMissingTrackedReposWarning(r.missingTrackedRepos)
+			} else {
+				r, updateErr = updateTrackedRepo(uc, t.name)
+			}
 		} else {
 			r, updateErr = updateRegularSkill(uc, t.name)
 		}

internal/git/info.go

@@ -495,16 +495,21 @@ func PushRemoteWithAuth(dir string) error {
 }
 
 // PushRemoteWithEnv pushes to the default remote with additional environment
-// variables.
+// variables. Error output is sanitized of credential values via WrapGitError.
 func PushRemoteWithEnv(dir string, extraEnv []string) error {
 	cmd := exec.Command("git", "push")
 	cmd.Dir = dir
 	if len(extraEnv) > 0 {
 		cmd.Env = append(os.Environ(), extraEnv...)
 	}
-	out, err := cmd.CombinedOutput()
+
+	var outBuf bytes.Buffer
+	cmd.Stdout = &outBuf
+	cmd.Stderr = &outBuf
+
+	err := cmd.Run()
 	if err != nil {
-		return fmt.Errorf("git push failed: %s", strings.TrimSpace(string(out)))
+		return install.WrapGitError(outBuf.String(), err, install.UsedTokenAuth(extraEnv))
 	}
 	return nil
 }