clients

type AssetBundle struct {
	Asset    *lockfile.Asset
	Metadata *metadata.Metadata
	ZipData  []byte
}

type AssetResult struct {
	AssetName string
	Status    ResultStatus
	Message   string
	Error     error
}

type BaseClient struct {
	// contains filtered or unexported fields
}

type Client interface {
	// Identity
	ID() string          // Machine name: "claude-code", "cursor", "cline"
	DisplayName() string // Human name: "Claude Code", "Cursor", "Cline"

	// Detection
	IsInstalled() bool  // Check if this client is installed/configured
	GetVersion() string // Get client version (empty if not available)

	// Capabilities - what asset types this client supports
	SupportsAssetType(assetType asset.Type) bool

	// Installation - client has FULL control over installation mechanism
	// Receives all assets to install at once (batch)
	InstallAssets(ctx context.Context, req InstallRequest) (InstallResponse, error)

	// Uninstallation - remove assets
	UninstallAssets(ctx context.Context, req UninstallRequest) (UninstallResponse, error)

	// Asset operations - for MCP server support
	// ListAssets returns all installed assets for a given scope
	ListAssets(ctx context.Context, scope *InstallScope) ([]InstalledSkill, error)
	// ReadSkill reads the content of a specific skill by name
	ReadSkill(ctx context.Context, name string, scope *InstallScope) (*SkillContent, error)

	// EnsureAssetSupport ensures asset infrastructure is set up for the current context.
	// This is called after installation to ensure rules files, MCP servers, etc. are configured.
	// For Cursor, this creates local .cursor/rules/skills.md with skills from all applicable scopes.
	// Clients that don't need post-install setup can return nil.
	EnsureAssetSupport(ctx context.Context, scope *InstallScope) error

	// GetBootstrapOptions returns bootstrap options provided by this client.
	// These are options for hooks, MCP servers, or other infrastructure the client provides.
	GetBootstrapOptions(ctx context.Context) []bootstrap.Option

	// GetBootstrapPath returns the path where bootstrap config is stored.
	// This is used for display purposes during init.
	// Returns empty string if not applicable.
	GetBootstrapPath() string

	// InstallBootstrap installs client infrastructure (hooks, MCP servers, etc.).
	// This sets up hooks for auto-update/usage tracking and registers the sx MCP server.
	// Called during installation to ensure all client infrastructure is in place.
	// The opts parameter contains only the enabled bootstrap options to install.
	// Clients that don't need bootstrap can return nil.
	InstallBootstrap(ctx context.Context, opts []bootstrap.Option) error

	// UninstallBootstrap removes client infrastructure installed by InstallBootstrap.
	// This removes hooks and unregisters the sx MCP server.
	// Called during full uninstall (--all flag) to clean up system infrastructure.
	// The opts parameter contains only the bootstrap options to uninstall.
	// Clients that don't need bootstrap can return nil.
	UninstallBootstrap(ctx context.Context, opts []bootstrap.Option) error

	// ShouldInstall checks if installation should proceed in hook mode.
	// Returns true to proceed, false to skip.
	// Called before any installation work begins.
	// For clients like Cursor that fire hooks on every prompt, this enables
	// tracking conversation IDs to only run install once per conversation.
	ShouldInstall(ctx context.Context) (bool, error)

	// VerifyAssets checks if assets are actually installed (not just tracked).
	// Used by --repair mode to detect discrepancies between tracker and filesystem.
	// Each client implements verification according to its own installation structure.
	VerifyAssets(ctx context.Context, assets []*lockfile.Asset, scope *InstallScope) []VerifyResult

	// ScanInstalledAssets scans for all installed assets of supported types.
	// Used during init to detect existing assets that could be imported into the vault.
	ScanInstalledAssets(ctx context.Context, scope *InstallScope) ([]InstalledAsset, error)

	// GetAssetPath returns the filesystem path to an installed asset.
	// Used during import to pass the asset directory to the add command.
	// Returns an error for asset types that don't have a simple directory structure.
	GetAssetPath(ctx context.Context, name string, assetType asset.Type, scope *InstallScope) (string, error)

	// RuleCapabilities returns this client's capabilities for handling rules.
	// Returns nil if the client doesn't support rules.
	RuleCapabilities() *RuleCapabilities
}

type InstallOptions struct {
	Force   bool // Force reinstall even if already installed
	DryRun  bool // Don't actually install, just validate
	Verbose bool // Verbose output
}

type InstallRequest struct {
	Assets  []*AssetBundle // All assets to install (batch)
	Scope   *InstallScope  // Where to install (global/repo/path)
	Options InstallOptions // Additional options
}

type InstallResponse struct {
	Results []AssetResult
}

type InstallScope struct {
	Type     ScopeType // Global, Repository, Path
	RepoRoot string    // Repository root (if applicable)
	RepoURL  string    // Repository URL (if applicable)
	Path     string    // Specific path within repo (if applicable)
}

type InstalledAsset struct {
	Name        string     // Asset name
	Description string     // Asset description from metadata
	Version     string     // Asset version
	Type        asset.Type // Asset type (skill, command, agent, etc.)
}

type InstalledSkill struct {
	Name        string // Skill name
	Description string // Skill description from metadata
	Version     string // Skill version
}

type Orchestrator struct {
	// contains filtered or unexported fields
}

type ParsedRule struct {
	// Globs are the file patterns this rule applies to.
	// This is the canonical format - clients may call this "paths", "globs", or "applyTo".
	Globs []string

	// Description is a short description of the rule.
	Description string

	// ClientFields contains client-specific fields that don't have a canonical equivalent.
	// For example, Cursor's "alwaysApply" field.
	ClientFields map[string]any

	// ClientName is the name of the client that parsed this rule.
	// Empty if no client was detected.
	ClientName string

	// Content is the clean markdown content without frontmatter.
	Content string
}

type Registry struct {
	// contains filtered or unexported fields
}

type ResultStatus string

type RuleCapabilities struct {
	// ClientName is the identifier for this client (e.g., "claude-code", "cursor")
	ClientName string

	// RulesDirectory is where rules are stored (e.g., ".claude/rules", ".cursor/rules")
	RulesDirectory string

	// FileExtension is the file extension for rules (e.g., ".md", ".mdc")
	FileExtension string

	// InstructionFiles are files that can be parsed for rule sections (e.g., "CLAUDE.md", "AGENTS.md")
	InstructionFiles []string

	// MatchesPath checks if a path belongs to this client's rules
	MatchesPath func(path string) bool

	// MatchesContent checks if content appears to belong to this client
	MatchesContent func(path string, content []byte) bool

	// ParseRuleFile parses a rule file and returns the canonical format
	ParseRuleFile func(content []byte) (*ParsedRule, error)

	// GenerateRuleFile creates a complete rule file for this client
	GenerateRuleFile func(cfg *metadata.RuleConfig, body string) []byte

	// DetectAssetType determines what type of asset this file is.
	// Returns nil if the client doesn't recognize the file.
	// content may be nil if the file hasn't been read yet.
	DetectAssetType func(path string, content []byte) *asset.Type
}

type ScopeType string

type SkillContent struct {
	Name        string // Skill name
	Description string // Skill description from metadata
	Version     string // Skill version from metadata
	Content     string // Contents of SKILL.md (or configured prompt file)
	BaseDir     string // Directory where skill is installed (for resolving @ file references)
}

type UninstallOptions struct {
	Force   bool // Force uninstall even if dependencies exist
	DryRun  bool // Don't actually uninstall
	Verbose bool // Verbose output
}

type UninstallRequest struct {
	Assets  []asset.Asset
	Scope   *InstallScope
	Options UninstallOptions
}

type UninstallResponse struct {
	Results []AssetResult
}

type VerifyResult struct {
	Asset     *lockfile.Asset // The asset that was verified
	Installed bool            // Whether the asset is actually installed correctly
	Message   string          // Details about what was found or missing
}