Cleanup after #523: install.MoveLockPins shared by skillmove and the project reconcile; one server store reload and reconcile dispatcher; adoption skips the source walk when no plain record's directory is missing.
Add skillshare move and POST /api/resources/batch/move so skills and
whole folders can change folder inside the source while keeping their
.metadata.json entry, accepted audit findings, lockfile pin, config
group, .gitignore and literal .skillignore lines. Moving by hand lost
the record and made the next install start over. install --into now
refuses a folder inside a skill or a tracked checkout.
Refs #510
* fix(install): keep a moved skill's record instead of reinstalling it
Install records are keyed by path, so a skill moved with mv shows up as
missing. "Install missing" (and bare `skillshare install`) then cloned it
again at the old path, leaving two copies that both sync to targets, and
reconcile could hand the new copy's record to the moved one.
A gone record now follows an unrecorded directory of the same name whose
files match the recorded hashes, when exactly one such directory exists.
Install-from-config skips such entries and reconcile re-keys the record,
so the moved copy keeps its source. Same-name skills with other files are
left alone, so an update can never overwrite them from that source.
Refs: #510
* fix(install): keep audit acceptances and unreadable links out of moves
Re-keying a moved skill went through Remove, which also drops the audit
findings accepted for the old path, so an unchanged skill could block or
prompt again on its next update. MoveEntry now carries them to the new key.
A record below a first-level source link that cannot be read looks gone
to Lstat, so an identical copy elsewhere could take its record while the
link was down. Such records are no longer matched as moved.
* fix(install): drop legacy-path acceptances and respect lock pins on move
A legacy basename key such as `demo` with group `old` keeps its accepted
audit findings under `old/demo`. MoveEntry removed only the key's own
acceptances, so the old path kept them and a later skill placed there
would inherit them without a new --force. It now deletes the old path.
When the lockfile pins another commit than the moved copy holds, treating
the copy as the moved skill re-keyed its stale record and let the project
lock be rewritten with the older commit. Such copies no longer count as a
move, so the pinned commit is installed as before.
* fix(install): search for moved skills only where reconcile looks
The search for a moved copy walked into installed skills and tracked
checkouts, which reconcile skips. A copy found there made install skip the
skill, then reconcile never saw the copy and pruned the record, and in
project mode the config entry with it. The search now stops at the same
boundaries.
* fix(install): never take a recorded skill as another's moved copy
Two identical skills can be recorded at different paths. When one of them
went missing, the other matched its hashes and was taken as its moved
copy, so install skipped the missing skill and reconcile pruned its record.
A directory with a record of its own is now never a move destination.
* fix(install): derive moved-copy paths from the resolved source root
sourcewalk.WalkDir reports paths under the resolved source root, but the
moved-copy search took them relative to the unresolved one. With a linked
source (or Windows short temp paths) every path came out as ../..., so the
installed-skill boundary never matched and a copy inside an installed
parent could be taken as the move, after which reconcile pruned the record.
The search now resolves the root first, as reconcile does.
* fix(install): move a record only to one copy of what the config declares
Three cases still let a move drop or misplace a record:
- In project mode the manifest can point a skill at a new source while a
copy of the old one exists elsewhere; that copy was taken as the skill,
so the new source was never installed. The record's source and branch
must now match the config entry.
- A git checkout reconcile treats as tracked could be accepted before the
tracked boundary was checked; the boundaries now run first.
- With two identical copies, reconcile re-keyed the record to whichever
it walked first. Both reconcile and the install-from-config search now
require exactly one destination, and reconcile decides after the walk.
* fix(install): clear accepted findings left at a move destination
A removed legacy grouped entry can leave findings accepted for its path
behind. MoveEntry only wrote the destination when the moved skill had its
own acceptances, so a skill moved into that path inherited findings it
never accepted. The destination is now cleared before the transfer.
* fix(install): follow a moved skill only while its declaration still matches
The install-from-config search compared source and branch but not the
tracking mode, so a skill switched to tracked was satisfied by an old
plain copy and never cloned.
Project reconciliation, which other installs also run, inferred moves
without looking at the manifest at all. A record whose declaration now
names another source could follow a copy of the old source, after which
the manifest entry was rewritten to that old source. Moves in project
mode now require the declaration to still match the record, through the
same MatchesDeclaration check the install path uses.
* fix(install): infer no move while a source link is unreadable
An unreadable followed source link can hide a second identical copy, so
a copy that looked unique could take the record arbitrarily. Reconcile
and the install-from-config search now infer a move only from a complete
inventory; reconcile already keeps the gone record in that case.
* fix(install): infer no move when the source walk hit an error
Both walks dropped traversal errors, so an unreadable directory that hid
a second identical copy left the visible one looking unique and it could
take the record. Any walk error now counts as an incomplete inventory,
like an unreadable source link, and no move is inferred from it.
* fix(install): keep a record whose move waits on a failed walk
When a walk error deferred a move, the walk still counted as complete, so
pruning dropped the gone record along with its accepted audit findings
and it could never follow the copy. A failed walk that deferred a move
now marks the inventory incomplete, as an unreadable source link does;
a failed walk with no move candidate keeps the old behavior.
Also correct InstallFromConfig's comments, which still said reconcile
runs only after an install.
* fix(install): move a moved skill's gitignore rule in project mode
Project reconcile added the managed ignore rule for a moved skill's new
path but left the old one, and the gitignore update only ever adds. If
the old path later held source-controlled files, Git kept ignoring them
without a word. Reconcile now reports the paths records moved away from,
and project reconcile removes their managed rules before adding the new.
* test(config): skip the unreadable-directory reconcile test on Windows
Windows does not stop reading a directory created with mode 0, and
os.Geteuid reports -1 there, so the root-only skip let the test run and
fail on the Windows runner.
* fix(install): count a candidate that cannot be hashed as an incomplete search
MovedEntryKey dropped a same-name candidate whose files could not be
hashed, so a readable identical copy beside it looked unique and could
take the record. It now returns the hash error, and reconcile and the
install-from-config search treat it like a walk error: no move is
inferred from that scan, and reconcile keeps the record waiting.
* fix(collect,install): collect only real skills; let --track take a local git path
collect treated every directory in a target as a local skill, so a scratch
folder was listed and `collect --force` copied it into the source. A folder
now counts only when it holds SKILL.md; the dashboard scan shares
FindLocalSkills and the dashboard collect request rejects such a folder.
`install /path/to/repo --track` failed with "requires a git repository
source" while file:///path worked. A local path that is a git repository
root is now normalized to the same file:// clone URL for --track (also past
the --branch guard); other local folders get an error that names file://.
Help text, docs (English and i18n) and the built-in skill reference follow.
* fix(install): keep the drive letter in file:// clone URLs for local --track paths
A Windows path such as C:/repo produced file://C:/repo, which makes C: the
URI authority instead of part of the path, so a tracked install from a local
Windows repository could clone the wrong location. Prefix the missing slash
so the URL is file:///C:/repo; POSIX paths are unchanged. Also cover the
dashboard install endpoint with a local-path --track test.
* fix(collect,install): keep UNC file URLs intact; require SKILL.md to be a file
The drive-letter fix lived in the helper shared with explicit file:// URLs,
which rewrote file://server/share/repo into a local path. Keep the slash
logic in the local-path --track case only and leave explicit URLs as parsed.
A subdirectory named SKILL.md passed the existence check, so a scratch folder
holding one was still collected. Both collect entry points (scan and the
dashboard request) now share sync.HasSkillFile, which rejects directories.
* fix(install): escape the local path in the file:// URL used by --track
Git decodes a file:// URL, so a repository path containing %20, %2F, a space
or # was cloned from a different path than the one IsGitRepo accepted. Build
the URL with net/url so those characters are escaped; drive-letter and POSIX
paths keep their form. The integration test now installs from a directory
whose name contains a space and a literal %20.
* fix(install): accept a local bare repository path for --track
A bare repository has HEAD and objects at its root but no .git entry, so the
local-path check rejected it while file:///same/path cloned fine. Add
IsLocalGitRepo (working tree or bare) and use it for both the --track
normalization and the --branch guard.
* test(install): build the bare repo path from a Windows file URL correctly
makeRemote returns file:///C:/dir on Windows; trimming only file:// left
/C:/dir, which filepath.Abs turned into D:\C:\dir, so the bare-repo test
failed on the Windows runner. Drop the slash before the drive letter.
* fix(install): refuse a --track local source that is the install destination
--force removes the tracked destination before cloning. When the local path
given to --track is that same directory, the removal deleted the only clone
source (and any unpushed work) before the clone failed. Compare the two with
os.SameFile, which also covers symlinked paths, and stop before touching the
destination.
* fix(install,collect): keep a tracked source inside its destination; reject special SKILL.md files
--track --force removed the destination before cloning, so a local source
nested below it (or given as an explicit file:// URL) was deleted along with
any unpushed work, and the clone then failed. Resolve the source and refuse
when it is the destination or lies under it, for dry runs too.
HasSkillFile used a not-a-directory test, so a FIFO named SKILL.md counted as
a skill and the collect copy blocked on it. Require a regular file; a
symlinked SKILL.md still resolves through os.Stat.
* fix(install): treat file://localhost URLs as local clone sources
Git clones file://localhost/path from the local filesystem, but the
containment guard only recognised an empty authority, so --track --force
could still delete a source given that way. Accept localhost (any case) as
local.
* test(install): build the localhost file URL from a slash path
On Windows the temp path starts with a drive letter, so prefixing it onto
file://localhost produced file://localhostC:\... instead of a valid URL and
the case failed on the Windows runner. Convert to slashes and add the
separator explicitly.
* fix(install): clone --track --force into a staging dir and swap it in last
--force removed the existing tracked repo before cloning, so any source that
lived under it (plain path, file:///, file://localhost, UNC, symlink or 8.3
alias) was destroyed before git could read it, and a failed clone also lost
the old repo. Clone beside the destination, run the checks and the audit on
the staging copy, then move the old repo aside, rename the new one in and
drop the backup; on any failure the staging copy is removed and the old repo
stays. The pre-removal containment refusal now covers plain local paths only
(the url.Parse special-casing is gone).
* fix(install): refuse a file:// --track source inside the forced destination
The staged swap in 7375400 still lost data for a file:///, file://localhost
or UNC source nested under the destination: the clone succeeded, the old repo
(with the source inside it) was renamed to the backup, and removing the backup
deleted the source's uncommitted work, which a clone cannot carry.
Restore the file URL to local path mapping (now including UNC hosts) so the
containment refusal covers every local spelling, not only plain paths. The
test now keeps an uncommitted file in the source and requires it to survive.
* fix(install): apply the source-inside-destination refusal only to --force
The refusal ran before the --update branch, so `install <tracked repo path>
--track --update` was rejected even though an update pulls the existing
checkout in place and removes nothing. Only the forced replacement can
destroy a source that lives under the destination, so check there.
* fix(install): report a forced clone's root skill under its tracked name
With --force the repo is discovered in the .skillshare-clone-<stamp> staging
directory, and discoverSkills names a root SKILL.md after the directory, so
the CLI summary, dashboard response and oplog listed a random staging name
instead of _foo. Use the tracked name for the root entry.
* fix(install): stage fresh tracked clones so cleanup never hits another installer
A fresh tracked install cloned straight into the destination, and the
deferred cleanup removed it on any failure. If another process created the
same tracked repo between the existence check and the clone, the failing
install deleted that process's checkout. Clone every install into its own
staging directory and rename it in last; a claimed destination makes the
rename fail and only the staging copy is removed.
Tracked repos are now named owner-repo, so repeating `install --track` for a
repo cloned earlier as _<basename> went to a new _owner-repo path and cloned a
second copy whose skills collide during sync. When that older checkout has
the same remote, keep using its name so the install skips as the same repo.
Bare `skillshare install` already restores everything .metadata.json records
but the disk lacks, yet the dashboard could only re-clone missing tracked
repos through a separate rehydrate path. Expose the CLI's install-from-config
flow instead (GET /api/install/missing, POST /api/install/from-config) so both
surfaces share one detection and one installer, and drop the old
missingTrackedRepos plumbing from update responses.
The install summary now counts tracked repos and their skills apart from
standalone skills, since "Installed 1 skill" hid a whole repo. New tracked
repos are named `_<owner>-<repo>` so two `skills` repos no longer collide;
existing installs keep their names. `check` passes the stale status through
so the dashboard can offer to prune skills deleted upstream.
Codex review of #481 found three problems with the shorthand change:
- `update org/team -p` and the dashboard stream updated the org/_team
repo even when a skill exists at org/team, which used to win because
the shorthand was not rewritten there. FindTrackedCheckoutUnlessSkill
skips the nested shorthand when a directory exists at the typed path;
plain names keep their repo-first behavior.
- Global `update team/` cleaned the name for repo matching but not for
skill matching, so it silently updated `_team` instead of reporting the
skill/repo collision that `update team` reports. resolveByBasename now
cleans the name once for both.
- The update.md example sits in the Project Mode section but lacked -p
(also in the four translations).
A repo installed with `--track --into org` lives at `org/_team`. Only
POST /api/update accepted `org/team`; the dashboard stream and
`update -p` prefixed the whole name (`_org/team`), and global `update`
compared the full name with the basename, so each reported not found.
Move the candidate rule (the name as typed, then `_` added to the last
segment, never leaving the source root) into install.FindTrackedCheckout
and the basename match into install.MatchTrackedRepos, and use them from
the single update, the stream, project and global CLI update. A shorthand
resolves to its own `org/_team`, never to a top-level `_team`; plain names
and full paths keep their behavior.
With --into repos from #472, org/_team and a top-level _team can share a
basename. When org/_team had no entry of its own, the root-skill hash
refresh found _team's entry through GetByPath's basename-only fallback and
overwrote its hashes, which later broke _team's integrity and up-to-date
checks. The refresh now only touches the repo's own entry (exact key, or a
legacy basename key with the matching group).
resolveTrackedRepo built the prefixed --into candidate with filepath.Join,
so on Windows the dashboard result came back as org\_team while #472 made
every other repo name slash-form, and the UI could not match the row.
Resolve the conflict in getTrackedReposImpl by keeping both sides: the
IsTrackedCheckout rule from this branch and the slash-form paths #472
returns for --into repos (org/_repo). Add a GetUpdatableSkills test for a
rewritten --into checkout next to a top-level one.
Simplify and code-review passes over #474 found the fix spread over
several definitions of "tracked repo" and three holes in the repair.
One install.IsTrackedCheckout (a _-prefixed git checkout) now backs
GetTrackedRepos, GetUpdatableSkills, the dashboard routing and the repair.
GetUpdatableSkills skipping such entries replaces the two CLI resolver
filters, so `skillshare check` and the dashboard Updates tab no longer list
a rewritten repo a second time as a regular skill. The repair checks that
one path instead of walking the whole source tree.
- Reconcile sets tracked on a checkout again without dropping type or
repo_url, so a rewritten entry that went through it was never cleaned.
The repair now also runs when those regular-install fields remain.
- The repair used GetByPath, whose basename fallback can return another
top-level item's entry; it now uses the repo's own key.
- A tracked entry whose checkout is gone fell through to the basename
fallback of resolveTrackedRepo and pulled a different repo with the same
basename. It now reports the repo as missing on disk.
The old dashboard update rewrote a tracked repo's metadata entry as a
regular install: tracked was dropped and type, repo_url and version were
added. Those repos stayed broken after the routing fix, because
`skillshare update <repo>` found the name twice (as a repo and as a
regular skill) and refused it, and nothing restored the entry.
The shared tracked-repo update now restores such an entry to what
install --track records (source, branch, group, tracked) when its path is
a checkout GetTrackedRepos lists, so regular skills are never touched.
CLI name and glob resolution skip a regular-skill match whose path is
already a tracked repo, so the update can reach that repair.
Codex review: the routing fix sent every git checkout with metadata to
the tracked-repo update, including standalone skills installed as a full
checkout, whose regular update records the new version and commit.
Their version stayed stale and update checks kept reporting an update.
Only tracked entries and _-prefixed checkouts now skip the regular path.
GetTrackedRepos returned OS-native paths, so every caller that compared
them with slash paths (RepoRelPath, dashboard repoPath, metadata keys)
had to convert first. Two callers in install_queries already did, and
this branch added four more. It now returns slash paths on every OS,
matching GetMissingTrackedRepos; filepath.Join and filepath.Base accept
them on Windows, and `update org/_repo` now also matches by full path
there. The per-call-site conversions are gone.
Smaller cleanups in the same code:
- repoOf takes the slash relPath and looks up prefixes by substring, so
the walk no longer splits and joins per directory;
- repo .skillignore matchers are keyed by the same slash rel path, so
isSkillIgnored no longer needs walkRoot;
- batch uninstall uses utils.IsTrackedRepoDir instead of a literal "_";
- the dashboard uses repoOf where it spelled out isInRepo && folderOf;
- the new tests reuse postBatchUninstall and share one --into sandbox.
The CLI and dashboard update a tracked repo through update.TrackedRepo,
which never looked for submodules. A pull that turned a skill directory
into a submodule reported success and the skill vanished on the next
sync. TrackedRepoResult now carries the skipped-submodule warnings and
both callers show them.
Refs #433
CLI search results install a repo-root skill through installFromGit without discovery, so the skipped-submodule warning has to come from that path too.
A failed or timed-out git ls-tree used to look like a repo without submodules, letting an empty submodule path through; the refusal check now reports the failure while warnings stay best effort. Tracked updates also warn about submodules in the pulled tree.
Gitlink paths and .gitmodules URLs come from an untrusted repo, so quote them with %q to keep newlines and terminal escapes out of CLI output. Compare each ancestor of the subdir with the gitlink directory by os.SameFile instead of a byte-length prefix, so case and Unicode-normalization variants that open the same directory are caught.
A --track install with an explicit kind skips discovery, so check the subdir after the tracked clone and remove it on refusal. Match a case variant of a gitlink path only when it opens the same directory, so Linux keeps a real Vendor/Up next to a vendor/up gitlink. Strip everything before the last @ in a submodule URL so malformed and scheme-relative values fail closed.
On Windows and macOS a case variant such as Vendor/Up opens the empty submodule checkout, so compare gitlink paths with EqualFold. Search results that install straight from discovery now show its warnings too.
Redact query, fragment and userinfo from relative, scp-style and malformed .gitmodules URLs too, clean the subdir before matching gitlinks so vendor//up is caught, and return discovery warnings from /api/discover so the install dialog shows skipped submodules.
skillshare never fetches submodules, so a gitlink is an empty directory
after any clone. Installing that path reported success with nothing in
it, a path inside it failed with a misleading "does not exist", and
whole-repo discovery dropped its skills without a word.
Refuse a subdir that is or lies inside a submodule, naming the
submodule, its pinned commit and upstream URL, and warn for each
submodule skipped by whole-repo discovery and --track.
Refs #433
Release-As: 0.25.1
Review of the shared uninstall operation found that RemoveByNames still
matched a bare key: removing top-level "foo" pruned the legacy entry
"foo" with Group "frontend", which belongs to the installed
frontend/foo. Entries are now matched by their full path only.
Also from review: a dry run no longer runs git status for tracked
repos (it reports no git state), the unused Outcome.Removed is gone,
the two single-item handlers share one status mapping, and the CLI
reports a single target in one place instead of three flag checks.
Refs #442
The dashboard update of N tracked repos loaded the metadata store 2N times
under the server lock, and each load walks the whole source tree. The refresh
now returns before loading when the repo has no root SKILL.md, reports
whether it saved a change, and the server reloads its store only then,
through the existing reloadSkillsStore.
The CLI single-repo path tracked its output with two flags and a OnceFunc.
The caller hook now runs once for every outcome, so the spinner stop, the
discard warning and the pull summary live in one place and print in the same
order as before.
auditGateFailClosed rebuilt three of its messages by hand; they are
AuditGateError's own wording with another subject, so both now come from one
function.
Refs #443
Review of the shared tracked-repo update found two regressions.
`install --track --update` lost "in tracked repository" from its message when
findings blocked and the rollback failed. The CLI builds its summary from
that phrase, so the old sentence is back, with the rollback part still coming
from AuditGateError.RollbackNote.
The dashboard dropped a failed metadata refresh without a trace, while the
CLI prints a warning. It is now logged.
trackedBlockMessage also gets a test: the dashboard offers Force Retry based
on its exact wording, and the server-level tests for the failed-rollback
branches went away with the old gate.
Refs #443
The uninstall sequence (move-out check, dirty check, move to trash,
.gitignore cleanup, metadata prune) lived in the CLI and in three
dashboard handlers, and the copies had drifted: three different prune
rule sets, no dirty check on DELETE /api/repos, and no metadata prune
at all on DELETE /api/resources, which left the removed skill's entry
and target overrides in .metadata.json.
internal/uninstall now owns the sequence for resolved items. Callers
keep name resolution, prompts, output, HTTP status and oplog.
MetadataStore.RemoveByNames is the single prune rule set: an entry goes
when it is a removed path or lies below one, by key or by Group, plus
the tracked legacy group of a top-level repo.
Behaviour changes, all intended:
- DELETE /api/repos/{name} refuses a dirty tracked repo, or one whose
git status cannot be read, with 409 unless ?force=true.
- DELETE /api/repos/{name} refuses a followed link whose folder is
itself a skill, like every other uninstall path.
- DELETE /api/resources/{name} prunes the skill's metadata.
- Removing top-level "foo" no longer prunes "frontend/foo" (CLI), and
removing repo "_team" no longer prunes the untracked group "team"
(dashboard batch); both dropped metadata of skills still installed.
Refs #442
Updating a tracked repo is a fail-closed sequence: check for uncommitted
changes, pull, audit what was pulled, reset to the pre-pull commit when the
audit blocks. The CLI had two copies of the pull flow, the dashboard a third,
and the audit gate existed four times (CLI, dashboard, and two in install).
The copies had drifted: the dashboard ignored a failed git status and never
refreshed root-skill metadata, and each copy worded a failed rollback on its
own.
update.TrackedRepo now owns the sequence and returns a structured result;
install.AuditGate is the only gate. internal/update is a new package because
internal/git already imports internal/install. The CLI keeps its spinner,
rows and the "Apply anyway?" prompt, passed in as one Confirm callback; the
dashboard turns the result into its JSON item.
Behaviour changes, all towards the stricter copy:
- the dashboard reports a failed git status as an error instead of pulling;
- the dashboard refreshes root-skill metadata after an update, like the CLI;
- a prompt that fails rolls the update back instead of leaving it applied;
- the rollback-failed and rollback-unavailable texts come from one place.
Accepted findings stay as they were (CLI honours and records them, the
dashboard does neither), now as the explicit AcceptedFindings input. The
"blocked and rolled back" texts are unchanged per caller because the
dashboard matches on them.
Refs #443
The GitHub, Gitea and CNB content API fallbacks wrote every file as
0644, so a skill's scripts lost their exec bit whenever sparse checkout
was not available. The APIs do not report the git mode, so a file that
starts with #! is now written as 0755; anything the kernel could run
directly carries one. The mode is set on both branches, because
O_TRUNC keeps the mode of a file that already existed.
Refs #439
The windows-latest runner's TEMP is an 8.3 short path
(C:\Users\RUNNER~1\...), while the product reports the resolved long
path. Four tests compared the short form and failed only on the runner;
the local guest has no short names. Resolve the expected path first.
Refs #344
These packages were left out of the windows-test job because of failures
that came from test assumptions (POSIX paths, permission bits, HOME,
bash shims posing as git), not product behavior. Fix them and add the
packages to the list so they stay green.
Two failures were real product bugs:
- swapStagedIntoSource named its backup like the temp that
sourcefs.MoveIn creates beside it. On a coarse clock (Windows) both
names matched, the failed move removed the temp and with it the
backup, and the old skill was lost.
- MetadataStore.GetByPath looked up OS-native paths in slash-form keys,
so `update --group` missed nested skills on Windows.
The test sandbox now also sets USERPROFILE, which os.UserHomeDir reads
on Windows; tests were reading the real profile.
Refs #344
Copy staged directory links as concrete content through the source root, skip dangling links, and reject directory cycles. Preserve the existing skill under a sibling name and restore it if moving or copying the replacement fails so followed checkout updates cannot discard the old content.
Followed worktrees and submodules were discovered as tracked repos but bypassed guards that required a .git directory. Widen IsGitRepo to accept a directory or regular gitdir file and reuse it in discovery and reconciliation. All existing callers classify checkouts or run Git commands; none requires the directory layout, so a separate predicate would retain inconsistent decisions.
Exercise actual followed worktrees in CLI and dashboard update fixtures, including project mode and force retries, and document that they receive the same checkout guards.
Missing-repo discovery ignored the operation follow policy, so tracked metadata added a skipped checkout back to update --all and allowed --force to reset it. Thread the policy through missing-repo detection and its CLI/server callers, including rehydration, so existing followed checkouts remain excluded.
Cover global and project updates with dirty tracked checkouts and force, as well as shared and dashboard rehydration. Document that --force does not override the batch skip.
Refuse install update pulls when a followed checkout has local changes or its Git status cannot be read, so audit rollback cannot discard unrelated user edits. Preserve ordinary and nil-policy behavior and cover both install routes and clean audit rollback.
Keep the analyzer metadata context logical while walking the resolved root, so integrity and publisher checks still find the source metadata store. Add global/project command regressions for linked repo roots and single skills, plus linked install-audit and trash sibling-list checks.
Pass the existing optional Follow policy through install audit gates and final metadata hashing, preserving default-off behavior. Absolute link text remains unchanged on trash rename fallback; relative links continue to store their absolute target.
Trash moves and restores the link entry without copying or removing its target, including when rename fails. Relative link text is stored as an absolute target so relocation cannot change its meaning; list and TUI expose the link target without inventorying its contents.
Pass the operation-scoped Follow policy into audit and hash operations, resolving their physical root while keeping logical result and metadata keys. Calls without a policy keep their existing behavior and ScanSkill retains its original function signature.
Update six stale trash raw-write allowances for the injected rename test seam and classify moveLink creation/removal: it moves a checked source entry to trash or restores an entry into source, never writes through its target. Raw sourcewalk calls and allowances are unchanged.
With follow_source_links on, discovery reports <source>/_dev-skills/foo,
but every write to it was refused: sourcefs rejects a link in the path, and
its source-root os.Root refuses descendants outside the source. Dashboard
edits, nested uninstall, regular skill replacement, and tracked installs
under such a link all failed, although writing through a link the user
placed is the agreed behavior (#410).
sourcefs.Open, Create, MkdirAllIn, and CheckMoveOut take the operation's
optional sourcewalk.Follow. A clean name <link>/<rest> whose first
component the policy follows is handled by a second os.Root opened at the
link's canonical target, with the same per-component link check on <rest>,
so a nested link or ".." still cannot escape the target. Names with ".."
keep the source root, which refuses them through the link. Without a
policy nothing changes.
The link entry itself stays a link: RemoveAll, Rename, and writes on it are
refused, install --track --force still refuses to replace it, and
CheckMoveOut still lets trash rename the link without following it.
MkdirAll on a followed link is a no-op, since it already is that directory;
install --into needs that. A rename across the link boundary is refused.
The install, update, uninstall, and server callers pass the same policy
their discovery uses, through InstallOptions.SourceFollow and the update
context. No raw-write allowance was needed.
Refs #274
Users link a checkout directly under the skills source (e.g.
skills/_dev-skills -> ~/code/dev-skills) and expect it to behave like any
other first-level entry. sourcewalk resolved only the root, so these links
were invisible to discovery, sync, update, and the dashboard.
follow_source_links (global and project config, default false) enables a
per-operation sourcewalk.Follow policy. Walk, WalkDir, and ReadDir report a
followed link under its own name as a directory and descend into its
target, so names, RelPath, FlatName, SourcePath, tracked-repo detection, and
metadata keys stay logical. Only entries directly under the source root are
followed. The policy is built from config and passed explicitly to every
discovery caller in the CLI, server, and reconcile, so counts agree; the
server keeps a per-instance snapshot refreshed on config load and save
instead of a process-global flag.
A link is skipped, with one warning per operation, when its target is
missing or unreadable, is the source or a parent of it, or overlaps an
active skills target. A missing or unreadable target marks the operation
incomplete: sync then skips pruning and copy-orphan deletion, and reconcile
keeps metadata, so an unmounted drive or a re-clone in progress cannot
erase target entries or install records. A link to an existing file is not
a directory link and stays an ordinary entry; treating it as incomplete
would disable pruning for anyone sharing a file such as .skillignore.
doctor keeps raw link identity: with the key off it still says the link is
not followed and names follow_source_links: true; with it on it reports
followed links and skipped links with the reason.
The raw-walk allowlist gains entries for the policy path in Walk and
WalkDir: the source root walk with a policy, and the walk of a validated
link target whose paths are remapped to the logical link path. Both live
in sourcewalk itself, the package that owns source traversal.
Refs #274
Implements rollout steps 1 and 2 of proposals/274-skillfollow.md. Nothing follows a link or parses .skillfollow yet.
Step 1: doctor reports first-level symlinks and junctions in the skills source as info, in text and JSON, without following them.
Step 2a: internal/sourcewalk owns traversal of the skills source. Thirteen raw walks move onto it with identical behavior, and a go/parser ratchet fails the tests on any new unclassified walk.
Step 2b: internal/sourcefs wraps an os.Root opened at the skills source and refuses any write whose path has a link component. The six write sites the proposal found in review move onto it, including the cross-device copy fallback, and a second ratchet covers raw os write calls. The only behavior change is that an explicit path crossing a link inside the source is refused instead of written through.
Refs #274
Release-As: 0.24.3
parseFileURL cleaned the path with filepath.Clean before prefixing it with
`file://`, and on Windows Clean rewrites the separators, so
`ss install file:///C:/repos/skills` handed git `file://\C:\repos\skills` and the
clone failed. The URL form is slash-based on every platform; only the local-path
branches need OS separators.
Convert back with filepath.ToSlash and pin the shape with a drive-letter case in
the existing table, which fails on Windows without the change and is inert on
Unix.
* fix(check): compare project-relative local sources and record install layout
Project installs record a local source as typed (./vendor/skill), relative
to the project root, so check skipped them. Resolve them against the project
root in both the CLI and the dashboard.
The copied shape of a local install was inferred from its file hashes, so a
CLI install whose source held only SKILL.md looked like a dashboard
collection-root install: a child skill added at the source later was neither
reported by check nor copied by update. Record the layout (skill-file or
directory) at install time and keep the hash heuristic only for entries
written before the field existed.
* fix(install): let a recorded layout decide the update shape without hashes
An entry whose hashing failed at install time still knows what was copied;
returning false there would turn a SKILL.md-only update into a full copy.
* fix(install): keep local installs updatable from any directory and in shape
Follow-ups to local-source change detection (#334):
- Global installs recorded a relative local path as typed, so `update`
and `check` resolved it against whatever directory they ran in and
failed with "source path does not exist". Global CLI and dashboard
installs now record the absolute path. Project mode keeps the path as
written, because .skillshare/config.yaml is shared across machines.
- The dashboard installs the root of a directory that also holds child
skills as its SKILL.md alone, but `update` re-copied the whole
directory, pulling in child skills and unrelated files. Updates now
keep that shape. The detection is shared with `check` so both agree on
which files belong to the install.
* fix(install): never narrow a whole-directory update to SKILL.md alone
The SKILL.md-only shape was inferred from a child skill in the source that
the recorded hashes lack. A whole-directory install whose source gained a
child skill later matched that too, so `update` replaced it with SKILL.md
alone and deleted its other files. Decide from the recorded files instead:
only an install that recorded SKILL.md alone keeps that shape.
extractGitFatal kept only git's "fatal:" line, so SSH clone/fetch failures
(install from git@host:..., hub indexes over SSH, updates) reported just
"Could not read from remote repository." and dropped the ssh line that says
why: publickey denied, host key verification, unresolved hostname, or a
refused/timed-out connection.
For that generic message, append the preceding transport line (skipping
"Cloning into" and warning chatter). When the reason is a publickey denial,
WrapGitError adds an "ssh -T user@host" hint. Other errors are unchanged.
Previewing a hub from the builder landed on an empty "pick a hub" state:
the builder and the browser kept separate copies of the drafts and the
browser's copy went stale. Merging both into one page removes the split,
so your own hub is shown exactly as others will see it and edited in place.
Hub entries can now be added from any repository URL, not only from
installed skills, with a branch or tag picked from the remote. The version
is written into the source URL, the only place the hub format keeps it,
and a new /api/hub/refs endpoint lists refs and rewrites sources so the UI
never builds tree/<ref> URLs itself. Skills added from installed ones keep
the version they were installed from.
Draft reads and saves read refs from the URLs only, so opening a hub never
waits on a remote. Added hubs get unique labels, since the default hub is
stored by label.
Installing from config set the branch only when one was recorded, so a
legacy entry with a tree/<tag>/... source and no branch was pinned to
that tag, while update kept it on the default branch. Use
ApplyRecordedBranch like the update paths do. Settling the ref up front
also lets web URL entries from one repo share a single clone again.
Refs #293
GitHub links to tree/HEAD/... when it means the default branch. Since
URL refs became clone refs, HEAD was taken as a branch name: with a
subdir the ref lookup failed, without one git clone --branch HEAD
failed. These URLs installed fine before, so keep them on the default
branch.
Refs #293
* feat(install): pin GitHub tree/blob URLs to their ref
Hub entries only carry a source URL, so a team hub had no way to pin a
third-party skill to a reviewed tag or commit. The parser already read
tree/<ref>/ and blob/<ref>/ URLs but discarded the ref, installing from
the default branch instead of the version the URL names.
Keep that ref as Source.Branch. An explicit --branch (CLI) or branch
(API body) still overrides it; the server handlers now only override
when a branch is given. Batch installs group by repo and ref so two
pinned versions of one repo get separate clones.
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
* docs(install): describe pinning hub sources to a tag or commit
Explain that a GitHub tree/<ref>/ source URL pins the install, in both
the hub index guide and the install reference.
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
* feat(install): pin GitLab/Bitbucket URLs and resolve refs containing "/"
Pinning should not depend on the host, so GitLab (-/tree/<ref>/) and
Bitbucket (src/<ref>/) web URLs now keep their ref too.
Taking the first path segment as the ref broke branch names containing
"/": tree/feature/x/skills/foo cloned branch "feature" and failed. When
the first segment is not a branch or tag on the remote, the longest
matching one is used instead. A ref the remote does not have fails
with a hint to use --branch, rather than silently installing the
default branch. A saved branch that covers more of the path (from
--branch or config) moves the subdir without asking the remote.
The grouped-install round-trip test pinned -/tree/main/ against a repo
on master; the ref used to be ignored, so its branch is now renamed.
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
* docs(install): cover GitLab, Bitbucket and "/" branches in URL pinning
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
* fix(install): keep web URL refs correct on reinstall, --branch and grouping
Review of the slash-branch resolution found four gaps:
- A saved branch equal to the whole URL tail (tree/feature/x) did not
move the subdir back, so every reinstall or update looked for "x".
- An unrelated --branch with a slash-branch URL kept the parse-time
subdir (x/skills/foo) instead of the URL's real one.
- Grouped installs copy the source to a repo root; resolution then put
the subdir back and discovery looked under a doubled path. Grouping
also keyed on the unresolved first segment, so tree/feature/x and
tree/feature/y could share one clone. Web URLs with a ref now install
on their own, and resolution leaves a repo-root copy at its root.
- A skill named after the parse-time subdir kept that name once the
path turned out to be all ref (tree/feature/x named the skill "x").
The unknown-ref error now reads as a missing ref first, since a stale
ref (tree/master after a rename) is more common than a slash branch.
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
* fix(update): keep legacy installs on the default branch
Skills installed before URL refs were honoured got the default branch
and recorded no branch. Single-skill update re-parses the recorded
source, so it moved them to the URL's ref (or failed on a stale one,
with a hint to pass --branch, which update does not accept), while
update --all rebuilds from RepoURL and kept the default branch.
ApplyRecordedBranch treats an empty recorded branch as the remote
default and drops the URL's ref. It replaces the branch handling at
every site that reinstalls from recorded metadata: CLI and server
update for skills and agents, and tracked-repo rehydration.
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
* perf(search): share one clone across pinned hub skills from a repo
Any web URL with a path after its ref installed on its own, so a hub
listing many tree/<tag>/ skills from one repo cloned it once per skill.
groupByRepo now resolves each URL's ref before grouping, with a
RemoteRefs cache that lists each remote's refs once, and groups by
repo and resolved ref. Only refs containing "/" (whose subdir the
discovery match cannot re-derive) and refs that fail to resolve still
install alone. A resolved source is marked settled so the grouped
clone does not resolve it again, and ApplyRecordedBranch settles the
subdir from a recorded branch without asking the remote.
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---------
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Willie <egg358358@gmail.com>