migs

type AddMigCommand ¶

type AddMigCommand struct {
	Client    *http.Client
	BaseURL   *url.URL
	Name      string           // Required: unique mig name.
	Spec      *json.RawMessage // Optional: initial spec (creates spec row and sets migs.spec_id).
	CreatedBy *string          // Optional: creator identifier.
}

AddMigCommand creates a new mig project. Endpoint: POST /v1/migs Creates a mig with unique name and optional initial spec.

func (c AddMigCommand) Run(ctx context.Context) (AddMigResult, error)

type AddMigRepoCommand ¶

type AddMigRepoCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	MigRef  domaintypes.MigRef // Required: mig ID or name.
	RepoURL string             // Required: git repository URL.
	BaseRef string             // Required: base git ref.
}

AddMigRepoCommand adds a repo to a mig's repo set. Endpoint: POST /v1/migs/{mig_id}/repos Adds a repo with URL and base ref.

func (c AddMigRepoCommand) Run(ctx context.Context) (domainapi.MigRepoSummary, error)

type AddMigResult ¶

type AddMigResult = domainapi.MigSummary

AddMigResult contains the response from creating a mig.

type ArchiveMigCommand ¶

type ArchiveMigCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	MigRef  types.MigRef // Required: mig ID or name to archive.
}

ArchiveMigCommand archives a mig project. Endpoint: PATCH /v1/migs/{mig_ref}/archive Refuses archival if the mig has running jobs.

func (c ArchiveMigCommand) Run(ctx context.Context) (ArchiveMigResult, error)

type ArchiveMigResult ¶

type ArchiveMigResult struct {
	ID       types.MigID `json:"id"`
	Name     string      `json:"name"`
	Archived bool        `json:"archived"`
}

ArchiveMigResult contains the response from archiving a mig.

type ArtifactsCommand ¶

type ArtifactsCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	RunID   domaintypes.RunID
	Output  io.Writer
}

ArtifactsCommand lists artifacts attached to a Migs run by stage.

func (c ArtifactsCommand) Run(ctx context.Context) error

type CreateMigRunCommand ¶

type CreateMigRunCommand struct {
	Client    *http.Client
	BaseURL   *url.URL
	MigRef    domaintypes.MigRef // Required: mig ID or name.
	RepoURLs  []string           // Optional: canonical repo URLs for "explicit" mode.
	Failed    bool               // If true, use "failed" mode; otherwise "all" or "explicit".
	CreatedBy *string            // Optional: creator identifier.
}

CreateMigRunCommand creates a launch wave from a mig project with repo selection. Endpoint: POST /v1/migs/{mig_id}/waves Creates a wave with run selection based on mode: all, explicit, or failed.

func (c CreateMigRunCommand) Run(ctx context.Context) (CreateMigRunResult, error)

type CreateMigRunResult ¶

type CreateMigRunResult struct {
	WaveID   domaintypes.WaveID `json:"wave_id"`
	MigID    domaintypes.MigID  `json:"mig_id"`
	SpecID   domaintypes.SpecID `json:"spec_id"`
	RunCount int                `json:"run_count"`
}

CreateMigRunResult contains the response from creating a mig wave.

type DiffEntry ¶

type DiffEntry struct {
	ID        domaintypes.DiffID      `json:"id"`
	JobID     domaintypes.JobID       `json:"job_id"`
	CreatedAt time.Time               `json:"created_at"`
	Size      int                     `json:"gzipped_size"`
	Summary   domaintypes.DiffSummary `json:"summary,omitempty"`
}

DiffEntry represents a single diff record from the list diffs response.

type DownloadDiffCommand ¶

type DownloadDiffCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	RunID   domaintypes.RunID // Run ID (KSUID-backed domain type)
	RepoID  domaintypes.RepoID
	DiffID  domaintypes.DiffID
	// Accumulated requests cumulative patch content up to DiffID.
	Accumulated bool
}

DownloadDiffCommand downloads a single diff patch via: GET /v1/runs/{run_id}/diffs?download=true&diff_id=<uuid> Returns the decompressed patch bytes ready for application via `git apply`.

func (c DownloadDiffCommand) Run(ctx context.Context) ([]byte, error)

type DownloadDiffGzipCommand ¶

type DownloadDiffGzipCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	RunID   domaintypes.RunID // Run ID (KSUID-backed domain type)
	RepoID  domaintypes.RepoID
	DiffID  domaintypes.DiffID
	// Accumulated requests cumulative patch content up to DiffID.
	Accumulated bool
}

DownloadDiffGzipCommand downloads a single diff patch as raw gzip bytes via: GET /v1/runs/{run_id}/diffs?download=true&diff_id=<uuid>

func (c DownloadDiffGzipCommand) Run(ctx context.Context) ([]byte, error)

type ImportError ¶

type ImportError struct {
	Line    int    `json:"line"`
	Message string `json:"message"`
}

ImportError represents a per-line error from CSV import.

type ImportMigReposCommand ¶

type ImportMigReposCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	MigRef  domaintypes.MigRef // Required: mig ID or name.
	CSVData []byte             // Required: CSV content with header: repo_url,base_ref
}

ImportMigReposCommand bulk imports repos for a mig from CSV. Endpoint: POST /v1/migs/{mig_id}/repos/bulk Imports repos from CSV with header: repo_url,base_ref.

func (c ImportMigReposCommand) Run(ctx context.Context) (ImportMigReposResult, error)

type ImportMigReposResult ¶

type ImportMigReposResult struct {
	Created int           `json:"created"`
	Updated int           `json:"updated"`
	Failed  int           `json:"failed"`
	Errors  []ImportError `json:"errors"`
}

ImportMigReposResult contains the response from bulk importing repos.

type ListMigReposCommand ¶

type ListMigReposCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	MigRef  domaintypes.MigRef // Required: mig ID or name.
}

ListMigReposCommand lists repos in a mig's repo set. Endpoint: GET /v1/migs/{mig_id}/repos Returns repos with ID, REPO_URL, BASE_REF, ADDED_AT.

func (c ListMigReposCommand) Run(ctx context.Context) ([]domainapi.MigRepoSummary, error)

type ListMigsCommand ¶

type ListMigsCommand struct {
	Client        *http.Client
	BaseURL       *url.URL
	Limit         int32   // Max results to return (default 50, max 100).
	Offset        int32   // Number of results to skip.
	NameSubstring *string // Optional: filter by name substring.
	Archived      *bool   // Optional: filter by archived status.
	RepoURL       *string // Optional: filter by repo URL in repo set.
}

ListMigsCommand lists mig projects with optional filters. Endpoint: GET /v1/migs Returns migs with ID, NAME, CREATED_AT, ARCHIVED status.

func (c ListMigsCommand) Run(ctx context.Context) ([]domainapi.MigSummary, error)

type ListRunDiffsCommand ¶

type ListRunDiffsCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	RunID   domaintypes.RunID // Run ID (KSUID-backed domain type)
	RepoID  domaintypes.RepoID
}

ListRunDiffsCommand fetches run-scoped diffs via GET /v1/runs/{run_id}/diffs.

Returns diffs filtered by repo_id via jobs.repo_id join. Diffs for repo A are excluded from repo B listing. Response shape is unchanged from legacy endpoint.

func (c ListRunDiffsCommand) Run(ctx context.Context) ([]DiffEntry, error)

type ListRunsCommand ¶

type ListRunsCommand struct {
	Client    *http.Client
	BaseURL   *url.URL
	Limit     int32 // Max results to return (default 50, max 100).
	Offset    int32 // Number of results to skip.
	RepoURL   string
	CreatedBy string
	All       bool
}

ListRunsCommand lists runs from the control plane.

func (c ListRunsCommand) Run(ctx context.Context) ([]domaintypes.RunSummary, error)

type MigPullCommand ¶

type MigPullCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	MigRef  domaintypes.MigRef
	RepoURL string   // Repository URL to match
	Mode    PullMode // Pull mode (last-succeeded or last-failed)
}

MigPullCommand resolves a repo_url to execution identifiers for a mig. Endpoint: POST /v1/migs/{mig_id}/pull

Server performs the lookup using mig_id + repo_url to find mig_repos.id, then selects the appropriate runs by created_at DESC, filtering by the requested terminal status (Success or Fail). Mode values:

• "last-succeeded" (default): newest runs with status=Success
• "last-failed": newest runs with status=Fail

Returns 404 if no repo matches or no run with matching status found.

func (c MigPullCommand) Run(ctx context.Context) (*PullResolution, error)

type PullMode ¶

type PullMode string

PullMode specifies which run to select for mig pull resolution.

const (
	// PullModeLastSucceeded selects the newest terminal run with status=Success (default).
	PullModeLastSucceeded PullMode = "last-succeeded"
	// PullModeLastFailed selects the newest terminal run with status=Fail.
	PullModeLastFailed PullMode = "last-failed"
)

type PullResolution ¶

type PullResolution struct {
	RunID           domaintypes.RunID  `json:"run_id"`
	RepoID          domaintypes.RepoID `json:"repo_id"`
	RepoURL         string             `json:"repo_url,omitempty"`
	SourceCommitSHA string             `json:"source_commit_sha,omitempty"`
}

PullResolution is the response from pull resolution endpoints. It provides the identifiers needed to fetch diffs:

• RunID: the run containing the execution
• RepoID: the mig_repos.id for the matched repo

type RemoveMigCommand ¶

type RemoveMigCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	MigRef  types.MigRef // Required: mig ID or name to delete.
}

RemoveMigCommand deletes a mig project. Endpoint: DELETE /v1/migs/{mig_ref} Refuses deletion if the mig has any runs.

func (c RemoveMigCommand) Run(ctx context.Context) error

type RemoveMigRepoCommand ¶

type RemoveMigRepoCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	MigRef  domaintypes.MigRef // Required: mig ID or name.
	RepoID  domaintypes.MigRepoID
}

RemoveMigRepoCommand deletes a repo from a mig's repo set. Endpoint: DELETE /v1/migs/{mig_id}/repos/{repo_id} Refuses deletion if there are historical executions referencing this repo.

func (c RemoveMigRepoCommand) Run(ctx context.Context) error

type ResolveMigByNameCommand ¶

type ResolveMigByNameCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	MigRef  types.MigRef // Mig reference (could be ID or name).
}

ResolveMigByNameCommand attempts to resolve a mig reference (ID or name) to a mig ID. It queries the server to find an exact name match, supporting both ID and name lookups. This command does NOT use any client-side heuristics to distinguish IDs from names; it always queries the server for resolution.

func (c ResolveMigByNameCommand) Run(ctx context.Context) (string, error)

type RunPullCommand ¶

type RunPullCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	RunID   domaintypes.RunID
}

RunPullCommand resolves execution identifiers and source metadata for a run. Endpoint: POST /v1/runs/{run_id}/pull

func (c RunPullCommand) Run(ctx context.Context) (*PullResolution, error)

type SetMigSpecCommand ¶

type SetMigSpecCommand struct {
	Client    *http.Client
	BaseURL   *url.URL
	MigRef    types.MigRef    // Required: mig ID or name.
	Spec      json.RawMessage // Required: spec content (YAML/JSON parsed to JSON).
	Name      *string         // Optional: spec name.
	CreatedBy *string         // Optional: creator identifier.
}

SetMigSpecCommand creates a new spec row and updates migs.spec_id. Endpoint: POST /v1/migs/{mig_ref}/specs Sets the mig's current spec by creating a new spec row.

func (c SetMigSpecCommand) Run(ctx context.Context) (SetMigSpecResult, error)

type SetMigSpecResult ¶

type SetMigSpecResult struct {
	ID        types.SpecID `json:"id"` // spec_id
	CreatedAt time.Time    `json:"created_at"`
}

SetMigSpecResult contains the response from setting a mig spec.

type SubmitCommand ¶

type SubmitCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	Request domainapi.RunSubmitRequest
}

SubmitCommand submits a Migs run to the control plane. The command submits a single-repo run via POST /v1/runs, then fetches the canonical Migs-style RunSummary via GET /v1/runs/{id}/status for display.

func (c SubmitCommand) Run(ctx context.Context) (migsapi.RunSummary, error)

type UnarchiveMigCommand ¶

type UnarchiveMigCommand struct {
	Client  *http.Client
	BaseURL *url.URL
	MigRef  types.MigRef // Required: mig ID or name to unarchive.
}

UnarchiveMigCommand unarchives a mig project. Endpoint: PATCH /v1/migs/{mig_ref}/unarchive Restores an archived mig to active status.

func (c UnarchiveMigCommand) Run(ctx context.Context) (UnarchiveMigResult, error)

type UnarchiveMigResult ¶

type UnarchiveMigResult struct {
	ID       types.MigID `json:"id"`
	Name     string      `json:"name"`
	Archived bool        `json:"archived"`
}

UnarchiveMigResult contains the response from unarchiving a mig.