agent/pkg/agentic/status.go

// SPDX-License-Identifier: EUPL-1.2

package agentic

import (
	"context"
	"time"

	core "dappco.re/go/core"
	"github.com/modelcontextprotocol/go-sdk/mcp"
)

// Workspace status file convention:
//
//   {workspace}/status.json  — current state of the workspace
//   {workspace}/repo/BLOCKED.md   — question the agent needs answered (written by agent)
//   {workspace}/repo/ANSWER.md    — response from human (written by reviewer)
//   {workspace}/.meta/agent-*.log — captured agent output
//
// Status lifecycle:
//   running → completed     (normal finish)
//   running → blocked       (agent wrote BLOCKED.md and exited)
//   blocked → running       (resume after ANSWER.md provided)
//   completed → merged      (PR verified and auto-merged)
//   running → failed        (agent crashed / non-zero exit)

// WorkspaceStatus represents the current state of an agent workspace.
//
//	st, err := ReadStatus(wsDir)
//	if err == nil && st.Status == "completed" { autoCreatePR(wsDir) }
type WorkspaceStatus struct {
	Status    string    `json:"status"`               // running, completed, blocked, failed
	Agent     string    `json:"agent"`                // gemini, claude, codex
	Repo      string    `json:"repo"`                 // target repo
	Org       string    `json:"org,omitempty"`        // forge org (e.g. "core")
	Task      string    `json:"task"`                 // task description
	Branch    string    `json:"branch,omitempty"`     // git branch name
	Issue     int       `json:"issue,omitempty"`      // forge issue number
	PID       int       `json:"pid,omitempty"`        // OS process ID (if running)
	ProcessID string    `json:"process_id,omitempty"` // go-process ID for managed lookup
	StartedAt time.Time `json:"started_at"`           // when dispatch started
	UpdatedAt time.Time `json:"updated_at"`           // last status change
	Question  string    `json:"question,omitempty"`   // from BLOCKED.md
	Runs      int       `json:"runs"`                 // how many times dispatched/resumed
	PRURL     string    `json:"pr_url,omitempty"`     // pull request URL (after PR created)
}

// WorkspaceQuery is the QUERY type for workspace state lookups.
// Returns the workspace Registry via c.QUERY(agentic.WorkspaceQuery{}).
//
//	r := c.QUERY(agentic.WorkspaceQuery{})
//	if r.OK { reg := r.Value.(*core.Registry[*WorkspaceStatus]) }
//	r := c.QUERY(agentic.WorkspaceQuery{Name: "core/go-io/task-5"})
type WorkspaceQuery struct {
	Name   string // specific workspace (empty = all)
	Status string // filter by status (empty = all)
}

func writeStatus(wsDir string, status *WorkspaceStatus) error {
	r := writeStatusResult(wsDir, status)
	if !r.OK {
		err, _ := r.Value.(error)
		if err == nil {
			err = core.E("writeStatus", "failed to write status", nil)
		}
		return err
	}
	return nil
}

// writeStatusResult writes status.json and returns core.Result.
//
//	r := writeStatusResult("/srv/core/workspace/core/go-io/task-5", &WorkspaceStatus{Status: "running"})
//	if r.OK { return }
func writeStatusResult(wsDir string, status *WorkspaceStatus) core.Result {
	if status == nil {
		return core.Result{Value: core.E("writeStatus", "status is required", nil), OK: false}
	}
	status.UpdatedAt = time.Now()
	statusPath := WorkspaceStatusPath(wsDir)
	if r := fs.WriteAtomic(statusPath, core.JSONMarshalString(status)); !r.OK {
		err, _ := r.Value.(error)
		if err == nil {
			return core.Result{Value: core.E("writeStatus", "failed to write status", nil), OK: false}
		}
		return core.Result{Value: core.E("writeStatus", "failed to write status", err), OK: false}
	}
	return core.Result{OK: true}
}

// ReadStatus parses the status.json in a workspace directory.
//
//	st, err := agentic.ReadStatus("/path/to/workspace")
func ReadStatus(wsDir string) (*WorkspaceStatus, error) {
	r := ReadStatusResult(wsDir)
	if !r.OK {
		err, _ := r.Value.(error)
		if err == nil {
			return nil, core.E("ReadStatus", "failed to read status", nil)
		}
		return nil, err
	}

	st, ok := r.Value.(*WorkspaceStatus)
	if !ok || st == nil {
		return nil, core.E("ReadStatus", "invalid status payload", nil)
	}
	return st, nil
}

// ReadStatusResult parses status.json and returns a WorkspaceStatus pointer.
//
//	r := ReadStatusResult("/path/to/workspace")
//	if r.OK { st := r.Value.(*WorkspaceStatus) }
func ReadStatusResult(wsDir string) core.Result {
	r := fs.Read(WorkspaceStatusPath(wsDir))
	if !r.OK {
		err, _ := r.Value.(error)
		if err == nil {
			return core.Result{Value: core.E("ReadStatus", "status not found", nil), OK: false}
		}
		return core.Result{Value: core.E("ReadStatus", core.Concat("status not found for ", wsDir), err), OK: false}
	}
	var s WorkspaceStatus
	if ur := core.JSONUnmarshalString(r.Value.(string), &s); !ur.OK {
		err, _ := ur.Value.(error)
		if err == nil {
			return core.Result{Value: core.E("ReadStatus", "invalid status json", nil), OK: false}
		}
		return core.Result{Value: core.E("ReadStatus", "invalid status json", err), OK: false}
	}
	return core.Result{Value: &s, OK: true}
}

// --- agentic_status tool ---

// StatusInput is the input for agentic_status.
//
//	input := agentic.StatusInput{Workspace: "core/go-io/task-42", Limit: 50}
type StatusInput struct {
	Workspace string `json:"workspace,omitempty"` // specific workspace name, or empty for all
	Limit     int    `json:"limit,omitempty"`     // max results (default 100)
	Status    string `json:"status,omitempty"`    // filter: running, completed, failed, blocked
}

// StatusOutput is the output for agentic_status.
// Returns stats by default. Only blocked workspaces are listed (they need attention).
//
//	out := agentic.StatusOutput{Total: 42, Running: 3, Queued: 10, Completed: 25}
type StatusOutput struct {
	Total     int           `json:"total"`
	Running   int           `json:"running"`
	Queued    int           `json:"queued"`
	Completed int           `json:"completed"`
	Failed    int           `json:"failed"`
	Blocked   []BlockedInfo `json:"blocked,omitempty"`
}

// BlockedInfo shows a workspace that needs human input.
//
//	info := agentic.BlockedInfo{Name: "core/go-io/task-4", Repo: "go-io", Question: "Which API version?"}
type BlockedInfo struct {
	Name     string `json:"name"`
	Repo     string `json:"repo"`
	Agent    string `json:"agent"`
	Question string `json:"question"`
}

func (s *PrepSubsystem) registerStatusTool(server *mcp.Server) {
	mcp.AddTool(server, &mcp.Tool{
		Name:        "agentic_status",
		Description: "List agent workspaces and their status (running, completed, blocked, failed). Shows blocked agents with their questions.",
	}, s.status)
}

func (s *PrepSubsystem) status(ctx context.Context, _ *mcp.CallToolRequest, input StatusInput) (*mcp.CallToolResult, StatusOutput, error) {
	statusFiles := WorkspaceStatusPaths()

	var out StatusOutput

	for _, statusPath := range statusFiles {
		wsDir := core.PathDir(statusPath)
		name := WorkspaceName(wsDir)

		st, err := ReadStatus(wsDir)
		if err != nil {
			out.Total++
			out.Failed++
			continue
		}

		// If status is "running", check if PID is still alive
		if st.Status == "running" && st.PID > 0 {
			if !PIDAlive(st.PID) {
				blockedPath := workspaceBlockedPath(wsDir)
				if r := fs.Read(blockedPath); r.OK {
					st.Status = "blocked"
					st.Question = core.Trim(r.Value.(string))
				} else {
					if len(workspaceLogFiles(wsDir)) == 0 {
						st.Status = "failed"
						st.Question = "Agent process died (no output log)"
					} else {
						st.Status = "completed"
					}
				}
				writeStatus(wsDir, st)
			}
		}

		out.Total++
		switch st.Status {
		case "running":
			out.Running++
		case "queued":
			out.Queued++
		case "completed":
			out.Completed++
		case "failed":
			out.Failed++
		case "blocked":
			out.Blocked = append(out.Blocked, BlockedInfo{
				Name:     name,
				Repo:     st.Repo,
				Agent:    st.Agent,
				Question: st.Question,
			})
		}
	}

	return nil, out, nil
}