render

func Apply ¶

func Apply(
	p RenderPlan,
	reg *adapter.Registry,
	st *state.Targets,
	home string,
	userHome string,
	scope adapter.Scope,
	project string,
) ([]CollisionReport, map[string]bool, map[string]bool, error)

Apply commits a RenderPlan by constructing one Writer per agent and invoking adapter.Apply with that writer. The writer enforces the foreign-collision backup invariant on every destination write — there is no separate "guard" pass; the guarantee is intrinsic to the only write path adapters are permitted to use.

Returns the union of CollisionReports across all agents so the caller can surface them, plus the set of destination paths actually written this run (so the apply-error rescue can record state for exactly those files and no others). If any adapter returns an error, applies completed so far are NOT rolled back (each underlying iox.AtomicWrite is atomic per-file, but the plan as a whole is not transactional); the reports and written-set returned reflect the work done before the failure.

Deduplication: when two adapters emit a "write" op for the same path (e.g. a shared skill file written by both claude and opencode), the first one wins and the second is silently skipped. Content is deterministic per path, so skipping a duplicate is always safe.

func PreviewApply ¶

func PreviewApply(
	p RenderPlan,
	reg *adapter.Registry,
	st *state.Targets,
	home string,
	userHome string,
	scope adapter.Scope,
	project string,
) (reports []CollisionReport, unchanged, wouldChange map[string]bool, err error)

PreviewApply runs the apply pipeline through non-writing preview writers and reports what a real apply would do, without touching disk. It returns the foreign-collision reports a real apply would produce, plus the per-destination convergence verdict: `unchanged` paths already hold exactly the bytes apply would write (the dry-run shows them as "synced"), and `wouldChange` paths would be created or modified (shown as "write"). Used by `apply --dry-run`.

It supersedes the older op.Content-only collision preview: because it runs the real adapter Apply, each merge is performed for real (against the on-disk destination), so the preview's synced/write verdict and collision set match the eventual apply exactly rather than approximating it.

func Plan ¶

func Plan(r secrets.Resolved, reg *adapter.Registry, agents []string, scope adapter.Scope, project string, s *state.Targets, userHome string) (RenderPlan, error)

Plan asks each adapter named in agents to render the canonical model. Returns a RenderPlan, never writes anything. Use Apply() to commit.

s may be nil; when non-nil, OwnedKeys is populated on merge-json-keys ops from state.Keys so the apply pipeline knows which JSON-pointer paths it owns.

userHome (the user's $HOME, paths.HomeDir) is required so OwnedKeys lookups match the HOME-relative form state stores. It is NOT the agentsync home — dest files live under $HOME, not under ~/.agentsync.

func BuildReport ¶

func BuildReport(c source.Canonical, plan RenderPlan, agents []string) TranslationReport

BuildReport constructs a TranslationReport from the canonical model and a RenderPlan: one row per plugin (c.Plugins) × agent. Each row carries the per-agent component inventory (countMCPServers / countLSPServers honour enabled+agent targeting; commands/skills/subagents/hooks are model totals) and the skips from plan.PerAgent[agent].Skips.

coverage = full when skips==0; otherwise partial when the adapter still rendered something for the agent (plan ops non-empty), none when every hosted component was skipped. The rendered signal is the plan's ops, not the inventory counts — a hosted-but-unsupported component (e.g. an LSP server on an agent with no LSP concept) is counted in the inventory yet renders nothing, so its row is "none". A disabled plugin yields a single disabled-marker row. With no plugins installed, one "(base)" row per agent summarizes the whole canonical.

BuildReport does NOT itself correlate a component to its origin plugin — the projected canonical is flattened with no origin tag. Attribution is therefore the caller's choice of what model+plan to pass:

• apply passes the whole flattened model, so every plugin row carries the same global counts/skips (the documented summary behavior).
• `explain <id>` re-projects ONE plugin in isolation (marketplace.ProjectInstalled) and passes a model+plan holding only that plugin's components, so its row reflects that plugin alone.

func NewPreviewWriter ¶

func NewPreviewWriter(st *state.Targets, home, userHome string, scope adapter.Scope, project, agent string) *Writer

NewPreviewWriter constructs a Writer that records foreign-collision reports without performing any disk writes. Used by `apply --dry-run` to surface the same backup-and-overwrite events a real apply would produce.

func NewWriter ¶

func NewWriter(st *state.Targets, home, userHome string, scope adapter.Scope, project, agent string) *Writer

NewWriter constructs a Writer for one (agent, scope, project) tuple. The render layer creates one writer per agent during Apply. home is the agentsync home (backup root); userHome is the user's $HOME (state-key normalization base).