Files
archie/internal/gateway/dashboard_tools.go
T
sam 76ba97895f feat(webui): make Events one page with three tabs
Inspector, Bindings and Mappings were three sibling destinations in a
dropdown, for what is one chain read in order: an event, the mapping that
names its fields, the binding that decides what runs. They are now three
tabs on /events, and the bar carries Events as a link rather than a menu
with one child sharing its name.

The navigation entry is always live and the tabs prune themselves: each is
a separate capability, so a composition that can back only some of them
still reaches the ones it can, and an unreported section stays visible.
Which tabs exist, and which one is showing, lives in tab-selection.ts and
is unit-tested without a browser; the page owns the components and the
address bar. The old paths survive as bookmarks that redirect to their tab,
so a link or a learned URL still lands somewhere that works.

Three pages become tab panels: they lose their page-level headers -- the
page names the page -- and keep their own actions in a right-aligned row.
CapturesHeader.vue is absorbed into the Inspector panel, which is where its
stream status belongs.
2026-09-22 04:21:36 +10:00

122 lines
5.5 KiB
Go

package gateway
import (
"context"
"errors"
"fmt"
"strings"
"github.com/samcharles93/archie-core/internal/tools"
)
// DashboardPage describes one dashboard surface so the chat agent can both
// understand what each place is for and point the operator there.
type DashboardPage struct {
// Path is the route (e.g. "/tasks"). It is what the browser hash becomes.
Path string
// Label is the human name shown in navigation (e.g. "Tasks").
Label string
// Description is a one-line plain-language explanation of what the page
// shows, so the agent can answer "where do I go for that?" correctly.
Description string
}
// dashboardPages is the single source of truth for what the dashboard exposes.
// It is deliberately a package-level registry rather than a per-router field:
// the same pages are shown regardless of identity, and the prompt's current
// page line and the dashboard_navigate tool both draw from it, so the agent
// never points at a page it was not told about.
var dashboardPages = []DashboardPage{
{Path: "/", Label: "Dashboard", Description: "What Archie is working on, what needs you, and token spend."},
{Path: "/tasks", Label: "Tasks", Description: "Issues Archie has picked up, and where each one stands."},
{Path: "/workflows", Label: "Workflows", Description: "The routed workflows and their run history."},
{Path: "/skills", Label: "Skills", Description: "The SKILL.md capabilities Archie can activate."},
{Path: "/curators", Label: "Curators", Description: "Scheduled passes that curate Archie's memory and captures."},
{Path: "/events", Label: "Events", Description: "Captured inbound events, how their fields map, and which workflow they start."},
{Path: "/logs", Label: "Logs", Description: "The daemon log stream, filterable by level and component."},
{Path: "/channels", Label: "Channels", Description: "Inbound chat and notification channels, and their state."},
{Path: "/system/status", Label: "Status", Description: "Update state, configuration sources, and the listen address."},
{Path: "/system/appearance", Label: "Appearance", Description: "Theme and display preferences."},
{Path: "/system/tasks", Label: "Task settings", Description: "Work lifecycle: statuses, operator actions, and budgets."},
{Path: "/system/models", Label: "Models", Description: "Model roles and the providers backing them."},
{Path: "/system/repos", Label: "Repositories", Description: "Repositories Archie watches, and their per-repo gate overrides."},
{Path: "/system/identities", Label: "Identities", Description: "Persistent actors and lifecycle."},
{Path: "/system/advanced", Label: "Advanced", Description: "Identity, storage, sandboxing, and dangerous actions."},
}
// DashboardPages returns a copy of the dashboard page registry.
func DashboardPages() []DashboardPage {
out := make([]DashboardPage, len(dashboardPages))
copy(out, dashboardPages)
return out
}
// PageIndexResult is what page_index returns: the full list of dashboard pages
// and what each one shows, so the agent can answer where to go.
type PageIndexResult struct {
Pages []DashboardPage `json:"pages"`
}
// pageIndexTool returns the tool that lists every dashboard page. It is only
// registered for the web channel (see PageIndexTools), because pointing a
// non-web operator at an internal dashboard route is meaningless.
func pageIndexTool() (tools.ToolEntry, bool) {
entry := tools.ToolEntry{
Name: "page_index",
Toolset: "dashboard",
Description: "List every dashboard page and, in one line, what it shows. Use it to tell the operator where to go for something rather than guessing.",
Classification: tools.ClassIdempotent,
Handler: func(_ context.Context, _ map[string]any) (any, error) {
return PageIndexResult{Pages: DashboardPages()}, nil
},
}
return entry, true
}
// dashboardNavigateTool resolves a page path and returns the navigation the UI
// can follow. It validates against the registry and refuses an unknown route
// rather than guessing, so a chip is only ever produced for a real page.
func dashboardNavigateTool() (tools.ToolEntry, bool) {
entry := tools.ToolEntry{
Name: "dashboard_navigate",
Toolset: "dashboard",
Description: "Point the operator at a dashboard page. Pass the page path (e.g. /tasks). Returns the page to navigate to; the web chat renders it as a clickable chip. Never guess a path, look it up with page_index first.",
Classification: tools.ClassIdempotent,
Schema: tools.JSONSchema{
"type": "object",
"properties": map[string]any{
"path": map[string]any{
"type": "string",
"description": "The dashboard route to navigate to, e.g. /tasks. Must match a page_index entry.",
},
},
"required": []any{"path"},
},
Handler: func(_ context.Context, input map[string]any) (any, error) {
path := strings.TrimSpace(asString(input["path"]))
if path == "" {
return nil, errors.New("dashboard_navigate: path is required")
}
for _, p := range dashboardPages {
if p.Path == path {
return DashboardNavigateResult{Path: p.Path, Label: p.Label}, nil
}
}
return nil, fmt.Errorf("dashboard_navigate: unknown page %s", path)
},
}
return entry, true
}
// PageIndexTools returns the dashboard tools for a channel. Only the web UI
// has a dashboard (and only the web chat sends a Current page), so a non-web
// channel (e.g. telegram) gets none.
func PageIndexTools(channel string) []tools.ToolEntry {
if !strings.EqualFold(channel, "web") {
return nil
}
pageIndex, _ := pageIndexTool()
navigate, _ := dashboardNavigateTool()
return []tools.ToolEntry{pageIndex, navigate}
}