{
  "Error": null,
  "Failure": "",
  "ProjectResults": [
    {
      "Error": null,           // BUG: Shows {} when error exists
      "Failure": "",
      "PlanSuccess": {...},
      "PolicyCheckResults": null,
      "ApplySuccess": "",
      "VersionSuccess": "",
      "ImportSuccess": null,
      "StateRmSuccess": null,
      "Command": 1,
      "SubCommand": "",
      "RepoRelDir": ".",
      "Workspace": "default",
      "ProjectName": "",
      "SilencePRComments": null
    }
  ],
  "PlansDeleted": false
}

type ProjectResult struct {
    ProjectCommandOutput  // embedded
    Command           Name
    // ...
}

// server/events/command/project_result.go

// MarshalJSON implements custom JSON marshaling to properly serialize the Error field
// while maintaining backwards compatibility with the existing API response structure.
func (p ProjectResult) MarshalJSON() ([]byte, error) {
    // Convert error to string pointer for proper serialization
    var errMsg *string
    if p.Error != nil {
        msg := p.Error.Error()
        errMsg = &msg
    }

    // Use anonymous struct to control JSON output
    // This preserves the flat structure (no ProjectCommandOutput wrapper)
    return json.Marshal(&struct {
        Error              *string                    `json:"Error"`
        Failure            string                     `json:"Failure"`
        PlanSuccess        *models.PlanSuccess        `json:"PlanSuccess"`
        PolicyCheckResults *models.PolicyCheckResults `json:"PolicyCheckResults"`
        ApplySuccess       string                     `json:"ApplySuccess"`
        VersionSuccess     string                     `json:"VersionSuccess"`
        ImportSuccess      *models.ImportSuccess      `json:"ImportSuccess"`
        StateRmSuccess     *models.StateRmSuccess     `json:"StateRmSuccess"`
        Command            Name                       `json:"Command"`
        SubCommand         string                     `json:"SubCommand"`
        RepoRelDir         string                     `json:"RepoRelDir"`
        Workspace          string                     `json:"Workspace"`
        ProjectName        string                     `json:"ProjectName"`
        SilencePRComments  []string                   `json:"SilencePRComments"`
    }{
        Error:              errMsg,
        Failure:            p.Failure,
        PlanSuccess:        p.PlanSuccess,
        PolicyCheckResults: p.PolicyCheckResults,
        ApplySuccess:       p.ApplySuccess,
        VersionSuccess:     p.VersionSuccess,
        ImportSuccess:      p.ImportSuccess,
        StateRmSuccess:     p.StateRmSuccess,
        Command:            p.Command,
        SubCommand:         p.SubCommand,
        RepoRelDir:         p.RepoRelDir,
        Workspace:          p.Workspace,
        ProjectName:        p.ProjectName,
        SilencePRComments:  p.SilencePRComments,
    })
}

// MarshalJSON for Result to properly serialize top-level Error
func (c Result) MarshalJSON() ([]byte, error) {
    type Alias Result
    var errMsg *string
    if c.Error != nil {
        msg := c.Error.Error()
        errMsg = &msg
    }
    return json.Marshal(&struct {
        Error *string `json:"Error"`
        *Alias
    }{
        Error: errMsg,
        Alias: (*Alias)(&c),
    })
}

// server/events/command/project_context.go
type ProjectContext struct {
    // ... existing fields ...

    // API is true if this command was triggered via API endpoint rather than PR comment.
    // When true and Pull.Num == 0, PR-specific requirements (approved, mergeable) are skipped.
    API bool
}

// server/events/project_command_context_builder.go
func newProjectCommandContext(...) command.ProjectContext {
    return command.ProjectContext{
        // ... existing fields ...
        API: ctx.API,
    }
}

// server/events/command_requirement_handler.go
func (a *DefaultCommandRequirementHandler) validateCommandRequirement(...) (string, error) {
    for _, req := range requirements {
        switch req {
        case raw.ApprovedRequirement:
            // Skip for API calls without PR - approval is PR-specific
            if ctx.API && ctx.Pull.Num == 0 {
                ctx.Log.Info("skipping approval requirement for API call without PR number")
                continue
            }
            // ... existing approval check ...

        case raw.MergeableRequirement:
            // Skip for API calls without PR - mergeability is PR-specific
            if ctx.API && ctx.Pull.Num == 0 {
                ctx.Log.Info("skipping mergeable requirement for API call without PR number")
                continue
            }
            // ... existing mergeable check ...
        }
    }
}

# Drift detection request (no PR)
curl -X POST 'https://atlantis/api/plan' \
  -H 'X-Atlantis-Token: <secret>' \
  -H 'Content-Type: application/json' \
  -d '{
    "Repository": "org/repo",
    "Ref": "main",
    "Type": "Github",
    "Paths": [{"Directory": ".", "Workspace": "default"}]
  }'

// server/events/models/drift.go

// DriftSummary represents detected infrastructure drift
type DriftSummary struct {
    HasDrift       bool   `json:"has_drift"`
    ToImport       int    `json:"to_import"`
    ToAdd          int    `json:"to_add"`
    ToChange       int    `json:"to_change"`
    ToDestroy      int    `json:"to_destroy"`
    ToForget       int    `json:"to_forget"`
    ChangesOutside bool   `json:"changes_outside"`
    Summary        string `json:"summary"` // e.g., "2 to import, 2 to add, 1 to change, 0 to destroy, 1 to forget"
}

// DriftRepositoryKey identifies the VCS repository that owns drift status.
// VCSHostType should be Repo.VCSHost.Type.String().
type DriftRepositoryKey struct {
    VCSHostType string `json:"type"`
    Hostname    string `json:"hostname"`
    Repository  string `json:"repository"`
}

// DriftProjectKey identifies a drift status record for an Atlantis project on
// a specific ref. ProjectName is optional in atlantis.yaml, so Path and
// Workspace must be part of the storage key to avoid collisions between
// unnamed projects in the same repository. Ref must also be part of the key so
// drift checks against different branches do not overwrite each other.
type DriftProjectKey struct {
    Ref         string `json:"ref"`
    ProjectName string `json:"project_name,omitempty"`
    Path        string `json:"path"`
    Workspace   string `json:"workspace"`
}

// ParseDriftFromPlan extracts drift information from terraform plan output.
func ParseDriftFromPlan(planOutput string) DriftSummary {
    stats := NewPlanSuccessStats(planOutput)

    return DriftSummary{
        HasDrift:       stats.Changes || stats.ChangesOutside,
        ToImport:       stats.Import,
        ToAdd:          stats.Add,
        ToChange:       stats.Change,
        ToDestroy:      stats.Destroy,
        ToForget:       stats.Forget,
        ChangesOutside: stats.ChangesOutside,
        Summary:        (&PlanSuccess{TerraformOutput: planOutput}).Summary(),
    }
}

// GET /api/drift/status?type=Github&hostname=github.com&repository=org/repo&ref=main
//   &project=myproject&path=.&workspace=default
// type must use the canonical models.VCSHostType.String() value. Type,
// hostname, repository, and ref identify the VCS source. Project, path, and
// workspace are optional filters; path and workspace identify unnamed Atlantis
// projects. Ref is required so callers can distinguish drift runs for the same
// project on different branches.
type DriftStatusResponse struct {
    Repository DriftRepositoryKey `json:"repository"`
    Projects   []ProjectDrift    `json:"projects"`
    CheckedAt  time.Time         `json:"checked_at"`
}

type ProjectDrift struct {
    Repository  DriftRepositoryKey `json:"repository"`
    ProjectName string             `json:"project_name,omitempty"`
    Path        string             `json:"path"`
    Workspace   string             `json:"workspace"`
    Ref         string             `json:"ref"`
    Drift       DriftSummary       `json:"drift"`
    LastChecked time.Time          `json:"last_checked"`
}

// server/core/drift/storage.go

type DriftStorage interface {
    StoreDriftStatus(repo models.DriftRepositoryKey, status models.ProjectDrift) error
    GetDriftStatus(repo models.DriftRepositoryKey, key models.DriftProjectKey) (*models.ProjectDrift, error)
    ListDriftStatus(repo models.DriftRepositoryKey, ref string) ([]models.ProjectDrift, error)
}

// In-memory implementation for initial version
type InMemoryDriftStorage struct {
    mu     sync.RWMutex
    status map[models.DriftRepositoryKey]map[models.DriftProjectKey]models.ProjectDrift
}

// server/events/vcs/client.go

type Client interface {
    // ... existing methods ...

    // CreatePullRequest creates a new PR/MR for the repository.
    // Returns the created pull request or an error.
    CreatePullRequest(
        logger logging.SimpleLogging,
        repo models.Repo,
        opts CreatePullRequestOptions,
    ) (models.PullRequest, error)

    // CreateBranch creates a new branch from the given ref.
    CreateBranch(
        logger logging.SimpleLogging,
        repo models.Repo,
        branchName string,
        fromRef string,
    ) error
}

type CreatePullRequestOptions struct {
    Title       string
    Body        string
    HeadBranch  string   // Source branch (e.g., "drift-remediation-2025-01-21")
    BaseBranch  string   // Target branch (e.g., "main")
    Draft       bool
    Labels      []string
    Assignees   []string
}

// server/events/vcs/github/client.go

func (g *Client) CreatePullRequest(
    logger logging.SimpleLogging,
    repo models.Repo,
    opts vcs.CreatePullRequestOptions,
) (models.PullRequest, error) {
    owner, repoName := repo.Owner, repo.Name

    pr, _, err := g.client.PullRequests.Create(g.ctx, owner, repoName, &github.NewPullRequest{
        Title: github.String(opts.Title),
        Body:  github.String(opts.Body),
        Head:  github.String(opts.HeadBranch),
        Base:  github.String(opts.BaseBranch),
        Draft: github.Bool(opts.Draft),
    })
    if err != nil {
        return models.PullRequest{}, err
    }

    return models.PullRequest{
        Num:        pr.GetNumber(),
        HeadBranch: pr.GetHead().GetRef(),
        BaseBranch: pr.GetBase().GetRef(),
        URL:        pr.GetHTMLURL(),
        State:      models.OpenPullState,
        // ... other fields
    }, nil
}

func (g *Client) CreateBranch(
    logger logging.SimpleLogging,
    repo models.Repo,
    branchName string,
    fromRef string,
) error {
    owner, repoName := repo.Owner, repo.Name

    // Get the SHA of the source ref
    ref, _, err := g.client.Git.GetRef(g.ctx, owner, repoName, "refs/heads/"+fromRef)
    if err != nil {
        return fmt.Errorf("failed to get ref %s: %w", fromRef, err)
    }

    // Create new branch
    _, _, err = g.client.Git.CreateRef(g.ctx, owner, repoName, github.CreateRef{
        Ref: "refs/heads/" + branchName,
        SHA: ref.Object.GetSHA(),
    })
    if err != nil {
        return fmt.Errorf("failed to create branch %s: %w", branchName, err)
    }

    return nil
}

// server/events/vcs/gitlab/client.go

func (g *Client) CreatePullRequest(
    logger logging.SimpleLogging,
    repo models.Repo,
    opts vcs.CreatePullRequestOptions,
) (models.PullRequest, error) {
    labels := gitlab.LabelOptions(opts.Labels)
    title := opts.Title
    if opts.Draft {
        // GitLab's create-MR API uses a title prefix to create draft MRs.
        title = "Draft: " + title
    }

    mr, _, err := g.Client.MergeRequests.CreateMergeRequest(repo.FullName, &gitlab.CreateMergeRequestOptions{
        Title:        gitlab.String(title),
        Description:  gitlab.String(opts.Body),
        SourceBranch: gitlab.String(opts.HeadBranch),
        TargetBranch: gitlab.String(opts.BaseBranch),
        Labels:       &labels,
    })
    if err != nil {
        return models.PullRequest{}, err
    }

    return models.PullRequest{
        Num:        mr.IID,
        HeadBranch: mr.SourceBranch,
        BaseBranch: mr.TargetBranch,
        URL:        mr.WebURL,
        State:      models.OpenPullState,
    }, nil
}

// POST /api/drift/remediate
type DriftRemediatePath struct {
    Directory string `json:"directory" validate:"required"`
    Workspace string `json:"workspace,omitempty"`
}

type DriftRemediateRequest struct {
    Repository  string                `json:"repository" validate:"required"`
    Ref         string                `json:"ref" validate:"required"`  // Base branch
    Type        string                `json:"type" validate:"required"` // VCS type
    Projects    []string              `json:"projects,omitempty"`       // Projects to remediate
    Paths       []DriftRemediatePath  `json:"paths,omitempty"`
    Title       string                `json:"title,omitempty"`       // PR title
    Description string                `json:"description,omitempty"` // PR body
    Draft       bool                  `json:"draft,omitempty"`
    AutoMerge   bool                  `json:"auto_merge,omitempty"` // Enable auto-merge after approval
}

type DriftRemediateResponse struct {
    Success     bool               `json:"success"`
    PullRequest *PullRequestInfo   `json:"pull_request,omitempty"`
    Error       string             `json:"error,omitempty"`
}

type PullRequestInfo struct {
    Number  int    `json:"number"`
    URL     string `json:"url"`
    Branch  string `json:"branch"`
    Title   string `json:"title"`
}

// GET /api/projects?repository=org/repo
type ProjectsResponse struct {
    Projects []ProjectInfo `json:"projects"`
}

type ProjectInfo struct {
    Name         string `json:"name"`
    Repository   string `json:"repository"`
    Path         string `json:"path"`
    Workspace    string `json:"workspace"`
    Workflow     string `json:"workflow,omitempty"`
    AutoplanEnabled bool `json:"autoplan_enabled"`
}

// DELETE /api/locks?id=<url-escaped lock key from GET /api/locks>
// Requires X-Atlantis-Token authentication
func (a *APIController) ForceUnlock(w http.ResponseWriter, r *http.Request) {
    // Validate authentication
    // Extract lock ID from the id query parameter. Atlantis lock keys contain
    // slash separators, so they must not be modeled as a single path segment.
    // Call a.Locker.Unlock(lockID)
    // Return success/failure
}