537226bd4d
AX Quality Gates (RFC-025):
- Eliminate os/exec from all test + production code (12+ files)
- Eliminate encoding/json from all test files (15 files, 66 occurrences)
- Eliminate os from all test files except TestMain (Go runtime contract)
- Eliminate path/filepath, net/url from all files
- String concat: 39 violations replaced with core.Concat()
- Test naming AX-7: 264 test functions renamed across all 6 packages
- Example test 1:1 coverage complete
Core Features Adopted:
- Task Composition: agent.completion pipeline (QA → PR → Verify → Ingest → Poke)
- PerformAsync: completion pipeline runs with WaitGroup + progress tracking
- Config: agents.yaml loaded once, feature flags (auto-qa/pr/merge/ingest)
- Named Locks: c.Lock("drain") for queue serialisation
- Registry: workspace state with cross-package QUERY access
- QUERY: c.QUERY(WorkspaceQuery{Status: "running"}) for cross-service queries
- Action descriptions: 25+ Actions self-documenting
- Data mounts: prompts/tasks/flows/personas/workspaces via c.Data()
- Content Actions: agentic.prompt/task/flow/persona callable via IPC
- Drive endpoints: forge + brain registered with tokens
- Drive REST helpers: DriveGet/DrivePost/DriveDo for Drive-aware HTTP
- HandleIPCEvents: auto-discovered by WithService (no manual wiring)
- Entitlement: frozen-queue gate on write Actions
- CLI dispatch: workspace dispatch wired to real dispatch method
- CLI: --quiet/-q and --debug/-d global flags
- CLI: banner, version, check (with service/action/command counts), env
- main.go: minimal — 5 services + c.Run(), no os import
- cmd tests: 84.2% coverage (was 0%)
Co-Authored-By: Virgil <virgil@lethean.io>
107 lines
2.8 KiB
Go
107 lines
2.8 KiB
Go
// SPDX-License-Identifier: EUPL-1.2
|
|
|
|
package agentic
|
|
|
|
import (
|
|
"context"
|
|
core "dappco.re/go/core"
|
|
"github.com/modelcontextprotocol/go-sdk/mcp"
|
|
)
|
|
|
|
// --- agentic_status_remote tool ---
|
|
|
|
// RemoteStatusInput queries a remote core-agent for workspace status.
|
|
//
|
|
// input := agentic.RemoteStatusInput{Host: "charon"}
|
|
type RemoteStatusInput struct {
|
|
Host string `json:"host"` // Remote agent host (e.g. "charon")
|
|
}
|
|
|
|
// RemoteStatusOutput is the response from a remote status check.
|
|
//
|
|
// out := agentic.RemoteStatusOutput{Success: true, Host: "charon"}
|
|
type RemoteStatusOutput struct {
|
|
Success bool `json:"success"`
|
|
Host string `json:"host"`
|
|
Stats StatusOutput `json:"stats"`
|
|
Error string `json:"error,omitempty"`
|
|
}
|
|
|
|
func (s *PrepSubsystem) registerRemoteStatusTool(server *mcp.Server) {
|
|
mcp.AddTool(server, &mcp.Tool{
|
|
Name: "agentic_status_remote",
|
|
Description: "Check workspace status on a remote core-agent (e.g. Charon). Shows running, completed, blocked, and failed agents.",
|
|
}, s.statusRemote)
|
|
}
|
|
|
|
func (s *PrepSubsystem) statusRemote(ctx context.Context, _ *mcp.CallToolRequest, input RemoteStatusInput) (*mcp.CallToolResult, RemoteStatusOutput, error) {
|
|
if input.Host == "" {
|
|
return nil, RemoteStatusOutput{}, core.E("statusRemote", "host is required", nil)
|
|
}
|
|
|
|
addr := resolveHost(input.Host)
|
|
token := remoteToken(input.Host)
|
|
url := core.Concat("http://", addr, "/mcp")
|
|
|
|
sessionID, err := mcpInitialize(ctx, url, token)
|
|
if err != nil {
|
|
return nil, RemoteStatusOutput{
|
|
Host: input.Host,
|
|
Error: core.Concat("unreachable: ", err.Error()),
|
|
}, nil
|
|
}
|
|
|
|
rpcReq := map[string]any{
|
|
"jsonrpc": "2.0",
|
|
"id": 2,
|
|
"method": "tools/call",
|
|
"params": map[string]any{
|
|
"name": "agentic_status",
|
|
"arguments": map[string]any{},
|
|
},
|
|
}
|
|
body := []byte(core.JSONMarshalString(rpcReq))
|
|
|
|
result, err := mcpCall(ctx, url, token, sessionID, body)
|
|
if err != nil {
|
|
return nil, RemoteStatusOutput{
|
|
Host: input.Host,
|
|
Error: core.Concat("call failed: ", err.Error()),
|
|
}, nil
|
|
}
|
|
|
|
output := RemoteStatusOutput{
|
|
Success: true,
|
|
Host: input.Host,
|
|
}
|
|
|
|
var rpcResp struct {
|
|
Result struct {
|
|
Content []struct {
|
|
Text string `json:"text"`
|
|
} `json:"content"`
|
|
} `json:"result"`
|
|
Error *struct {
|
|
Code int `json:"code"`
|
|
Message string `json:"message"`
|
|
} `json:"error"`
|
|
}
|
|
if r := core.JSONUnmarshal(result, &rpcResp); !r.OK {
|
|
output.Success = false
|
|
output.Error = "failed to parse response"
|
|
return nil, output, nil
|
|
}
|
|
if rpcResp.Error != nil {
|
|
output.Success = false
|
|
output.Error = rpcResp.Error.Message
|
|
return nil, output, nil
|
|
}
|
|
if len(rpcResp.Result.Content) > 0 {
|
|
var statusOut StatusOutput
|
|
if r := core.JSONUnmarshalString(rpcResp.Result.Content[0].Text, &statusOut); r.OK {
|
|
output.Stats = statusOut
|
|
}
|
|
}
|
|
|
|
return nil, output, nil
|
|
}
|