1338 lines
50 KiB
Go
1338 lines
50 KiB
Go
// SPDX-License-Identifier: EUPL-1.2
|
|
|
|
// c := core.New(core.WithOption("name", "core-agent"))
|
|
// registerApplicationCommands(c)
|
|
|
|
package agentic
|
|
|
|
import (
|
|
"context"
|
|
|
|
"dappco.re/go/agent/pkg/lib"
|
|
core "dappco.re/go/core"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
// c.Command("run/task", core.Command{Description: "Run a single task end-to-end", Action: s.cmdRunTask})
|
|
// c.Command("prep", core.Command{Description: "Prepare a workspace: clone repo, build prompt", Action: s.cmdPrep})
|
|
func (s *PrepSubsystem) registerCommands(ctx context.Context) {
|
|
s.startupContext = ctx
|
|
c := s.Core()
|
|
c.Command("run/task", core.Command{Description: "Run a single task end-to-end", Action: s.cmdRunTask})
|
|
c.Command("agentic:run/task", core.Command{Description: "Run a single task end-to-end", Action: s.cmdRunTask})
|
|
c.Command("run/flow", core.Command{Description: "Show a flow definition from disk or the embedded library", Action: s.cmdRunFlow})
|
|
c.Command("agentic:run/flow", core.Command{Description: "Show a flow definition from disk or the embedded library", Action: s.cmdRunFlow})
|
|
c.Command("flow/preview", core.Command{Description: "Preview a flow definition with optional variable substitution", Action: s.cmdFlowPreview})
|
|
c.Command("agentic:flow/preview", core.Command{Description: "Preview a flow definition with optional variable substitution", Action: s.cmdFlowPreview})
|
|
c.Command("dispatch/sync", core.Command{Description: "Dispatch a single task synchronously and block until it completes", Action: s.cmdDispatchSync})
|
|
c.Command("agentic:dispatch/sync", core.Command{Description: "Dispatch a single task synchronously and block until it completes", Action: s.cmdDispatchSync})
|
|
c.Command("run/orchestrator", core.Command{Description: "Run the queue orchestrator (standalone, no MCP)", Action: s.cmdOrchestrator})
|
|
c.Command("agentic:run/orchestrator", core.Command{Description: "Run the queue orchestrator (standalone, no MCP)", Action: s.cmdOrchestrator})
|
|
c.Command("dispatch", core.Command{Description: "Dispatch queued agents", Action: s.cmdDispatch})
|
|
c.Command("agentic:dispatch", core.Command{Description: "Dispatch queued agents", Action: s.cmdDispatch})
|
|
c.Command("dispatch/start", core.Command{Description: "Start the dispatch queue runner", Action: s.cmdDispatchStart})
|
|
c.Command("agentic:dispatch/start", core.Command{Description: "Start the dispatch queue runner", Action: s.cmdDispatchStart})
|
|
c.Command("dispatch/shutdown", core.Command{Description: "Freeze the dispatch queue gracefully", Action: s.cmdDispatchShutdown})
|
|
c.Command("agentic:dispatch/shutdown", core.Command{Description: "Freeze the dispatch queue gracefully", Action: s.cmdDispatchShutdown})
|
|
c.Command("dispatch/shutdown-now", core.Command{Description: "Hard stop the dispatch queue and kill running agents", Action: s.cmdDispatchShutdownNow})
|
|
c.Command("agentic:dispatch/shutdown-now", core.Command{Description: "Hard stop the dispatch queue and kill running agents", Action: s.cmdDispatchShutdownNow})
|
|
c.Command("poke", core.Command{Description: "Drain the dispatch queue immediately", Action: s.cmdPoke})
|
|
c.Command("agentic:poke", core.Command{Description: "Drain the dispatch queue immediately", Action: s.cmdPoke})
|
|
c.Command("prep", core.Command{Description: "Prepare a workspace: clone repo, build prompt", Action: s.cmdPrep})
|
|
c.Command("prep-workspace", core.Command{Description: "Prepare a workspace: clone repo, build prompt", Action: s.cmdPrep})
|
|
c.Command("agentic:prep-workspace", core.Command{Description: "Prepare a workspace: clone repo, build prompt", Action: s.cmdPrep})
|
|
c.Command("resume", core.Command{Description: "Resume a blocked or completed workspace", Action: s.cmdResume})
|
|
c.Command("agentic:resume", core.Command{Description: "Resume a blocked or completed workspace", Action: s.cmdResume})
|
|
c.Command("generate", core.Command{Description: "Generate content from a prompt using the platform content pipeline", Action: s.cmdGenerate})
|
|
c.Command("agentic:generate", core.Command{Description: "Generate content from a prompt using the platform content pipeline", Action: s.cmdGenerate})
|
|
c.Command("content/generate", core.Command{Description: "Generate content from a prompt using the platform content pipeline", Action: s.cmdGenerate})
|
|
c.Command("agentic:content/generate", core.Command{Description: "Generate content from a prompt using the platform content pipeline", Action: s.cmdGenerate})
|
|
c.Command("content/schema/generate", core.Command{Description: "Generate SEO schema JSON-LD for article, FAQ, or how-to content", Action: s.cmdContentSchemaGenerate})
|
|
c.Command("agentic:content/schema/generate", core.Command{Description: "Generate SEO schema JSON-LD for article, FAQ, or how-to content", Action: s.cmdContentSchemaGenerate})
|
|
c.Command("complete", core.Command{Description: "Run the completion pipeline (QA → PR → Verify → Commit → Ingest → Poke)", Action: s.cmdComplete})
|
|
c.Command("agentic:complete", core.Command{Description: "Run the completion pipeline (QA → PR → Verify → Commit → Ingest → Poke)", Action: s.cmdComplete})
|
|
c.Command("scan", core.Command{Description: "Scan Forge repos for actionable issues", Action: s.cmdScan})
|
|
c.Command("agentic:scan", core.Command{Description: "Scan Forge repos for actionable issues", Action: s.cmdScan})
|
|
c.Command("mirror", core.Command{Description: "Mirror Forge repos to GitHub", Action: s.cmdMirror})
|
|
c.Command("agentic:mirror", core.Command{Description: "Mirror Forge repos to GitHub", Action: s.cmdMirror})
|
|
c.Command("brain/ingest", core.Command{Description: "Bulk ingest memories into OpenBrain", Action: s.cmdBrainIngest})
|
|
c.Command("brain:ingest", core.Command{Description: "Bulk ingest memories into OpenBrain", Action: s.cmdBrainIngest})
|
|
c.Command("brain/recall", core.Command{Description: "Recall memories from OpenBrain", Action: s.cmdBrainRecall})
|
|
c.Command("brain:recall", core.Command{Description: "Recall memories from OpenBrain", Action: s.cmdBrainRecall})
|
|
c.Command("brain/remember", core.Command{Description: "Store a memory in OpenBrain", Action: s.cmdBrainRemember})
|
|
c.Command("brain:remember", core.Command{Description: "Store a memory in OpenBrain", Action: s.cmdBrainRemember})
|
|
c.Command("brain/seed-memory", core.Command{Description: "Import markdown memories into OpenBrain from a project memory file or directory", Action: s.cmdBrainSeedMemory})
|
|
c.Command("brain:seed-memory", core.Command{Description: "Import markdown memories into OpenBrain from a project memory file or directory", Action: s.cmdBrainSeedMemory})
|
|
c.Command("brain/list", core.Command{Description: "List memories in OpenBrain", Action: s.cmdBrainList})
|
|
c.Command("brain:list", core.Command{Description: "List memories in OpenBrain", Action: s.cmdBrainList})
|
|
c.Command("brain/forget", core.Command{Description: "Forget a memory in OpenBrain", Action: s.cmdBrainForget})
|
|
c.Command("brain:forget", core.Command{Description: "Forget a memory in OpenBrain", Action: s.cmdBrainForget})
|
|
c.Command("lang/detect", core.Command{Description: "Detect the primary language for a repository or workspace", Action: s.cmdLangDetect})
|
|
c.Command("lang/list", core.Command{Description: "List supported language identifiers", Action: s.cmdLangList})
|
|
c.Command("epic", core.Command{Description: "Create sub-issues from an epic plan", Action: s.cmdEpic})
|
|
c.Command("agentic:epic", core.Command{Description: "Create sub-issues from an epic plan", Action: s.cmdEpic})
|
|
c.Command("plan-cleanup", core.Command{Description: "Archive old completed plans and delete stale archives past the retention period", Action: s.cmdPlanCleanup})
|
|
c.Command("agentic:plan-cleanup", core.Command{Description: "Archive old completed plans and delete stale archives past the retention period", Action: s.cmdPlanCleanup})
|
|
c.Command("pr-manage", core.Command{Description: "Manage open PRs (merge, close, review)", Action: s.cmdPRManage})
|
|
c.Command("agentic:pr-manage", core.Command{Description: "Manage open PRs (merge, close, review)", Action: s.cmdPRManage})
|
|
c.Command("review-queue", core.Command{Description: "Process the CodeRabbit review queue", Action: s.cmdReviewQueue})
|
|
c.Command("agentic:review-queue", core.Command{Description: "Process the CodeRabbit review queue", Action: s.cmdReviewQueue})
|
|
c.Command("status", core.Command{Description: "List agent workspace statuses", Action: s.cmdStatus})
|
|
c.Command("agentic:status", core.Command{Description: "List agent workspace statuses", Action: s.cmdStatus})
|
|
c.Command("prompt", core.Command{Description: "Build and display an agent prompt for a repo", Action: s.cmdPrompt})
|
|
c.Command("agentic:prompt", core.Command{Description: "Build and display an agent prompt for a repo", Action: s.cmdPrompt})
|
|
c.Command("prompt_version", core.Command{Description: "Read the current prompt snapshot for a workspace", Action: s.cmdPromptVersion})
|
|
c.Command("agentic:prompt_version", core.Command{Description: "Read the current prompt snapshot for a workspace", Action: s.cmdPromptVersion})
|
|
c.Command("prompt/version", core.Command{Description: "Read the current prompt snapshot for a workspace", Action: s.cmdPromptVersion})
|
|
c.Command("agentic:prompt/version", core.Command{Description: "Read the current prompt snapshot for a workspace", Action: s.cmdPromptVersion})
|
|
c.Command("extract", core.Command{Description: "Extract data from agent output or scaffold a workspace template", Action: s.cmdExtract})
|
|
c.Command("agentic:extract", core.Command{Description: "Extract data from agent output or scaffold a workspace template", Action: s.cmdExtract})
|
|
s.registerPlanCommands()
|
|
s.registerCommitCommands()
|
|
s.registerSessionCommands()
|
|
s.registerPhaseCommands()
|
|
s.registerTaskCommands()
|
|
s.registerSprintCommands()
|
|
s.registerStateCommands()
|
|
s.registerLanguageCommands()
|
|
s.registerSetupCommands()
|
|
}
|
|
|
|
// ctx := s.commandContext()
|
|
func (s *PrepSubsystem) commandContext() context.Context {
|
|
if s.startupContext != nil {
|
|
return s.startupContext
|
|
}
|
|
return context.Background()
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdRunTask(options core.Options) core.Result {
|
|
return s.runDispatchSync(s.commandContext(), options, "run task", "agentic.runTask")
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdRunFlow(options core.Options) core.Result {
|
|
return s.runFlowCommand(options, "run flow")
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdFlowPreview(options core.Options) core.Result {
|
|
return s.runFlowCommand(options, "flow preview")
|
|
}
|
|
|
|
func (s *PrepSubsystem) runFlowCommand(options core.Options, commandLabel string) core.Result {
|
|
flowPath := optionStringValue(options, "_arg", "path", "slug")
|
|
if flowPath == "" {
|
|
core.Print(nil, "usage: core-agent %s <path-or-slug> [--dry-run] [--var=key=value] [--vars='{\"key\":\"value\"}'] [--variables='{\"key\":\"value\"}']", commandLabel)
|
|
return core.Result{Value: core.E("agentic.cmdRunFlow", "flow path or slug is required", nil), OK: false}
|
|
}
|
|
|
|
dryRun := optionBoolValue(options, "dry_run", "dry-run")
|
|
variables := optionStringMapValue(options, "var", "vars", "variables")
|
|
|
|
flowResult := readFlowDocument(flowPath, variables)
|
|
if !flowResult.OK {
|
|
core.Print(nil, "error: %v", flowResult.Value)
|
|
return core.Result{Value: flowResult.Value, OK: false}
|
|
}
|
|
|
|
document, ok := flowResult.Value.(flowRunDocument)
|
|
if !ok {
|
|
err := core.E("agentic.cmdRunFlow", "invalid flow definition", nil)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
output := FlowRunOutput{
|
|
Success: true,
|
|
Source: document.Source,
|
|
Name: document.Definition.Name,
|
|
Description: document.Definition.Description,
|
|
Steps: len(document.Definition.Steps),
|
|
Parsed: document.Parsed,
|
|
}
|
|
|
|
core.Print(nil, "flow: %s", document.Source)
|
|
if dryRun {
|
|
core.Print(nil, "dry-run: true")
|
|
}
|
|
if len(variables) > 0 {
|
|
core.Print(nil, "vars: %d", len(variables))
|
|
}
|
|
if document.Parsed {
|
|
if document.Definition.Name != "" {
|
|
core.Print(nil, "name: %s", document.Definition.Name)
|
|
}
|
|
if document.Definition.Description != "" {
|
|
core.Print(nil, "desc: %s", document.Definition.Description)
|
|
}
|
|
if len(document.Definition.Steps) == 0 {
|
|
core.Print(nil, "steps: 0")
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
core.Print(nil, "steps: %d", len(document.Definition.Steps))
|
|
resolvedSteps := s.printFlowSteps(document, "", variables, map[string]bool{document.Source: true})
|
|
output.ResolvedSteps = resolvedSteps
|
|
if resolvedSteps != len(document.Definition.Steps) {
|
|
core.Print(nil, "resolved steps: %d", resolvedSteps)
|
|
}
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
if document.Content != "" {
|
|
core.Print(nil, "content: %d chars", len(document.Content))
|
|
}
|
|
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdDispatchSync(options core.Options) core.Result {
|
|
return s.runDispatchSync(s.commandContext(), options, "dispatch sync", "agentic.runDispatchSync")
|
|
}
|
|
|
|
func (s *PrepSubsystem) runDispatchSync(ctx context.Context, options core.Options, commandLabel, errorName string) core.Result {
|
|
repo := options.String("repo")
|
|
agent := options.String("agent")
|
|
task := options.String("task")
|
|
issueValue := options.String("issue")
|
|
org := options.String("org")
|
|
|
|
if repo == "" || task == "" {
|
|
core.Print(nil, "usage: core-agent %s --repo=<repo> --task=\"...\" --agent=codex [--issue=N] [--org=core]", commandLabel)
|
|
return core.Result{Value: core.E(errorName, "repo and task are required", nil), OK: false}
|
|
}
|
|
if agent == "" {
|
|
agent = "codex"
|
|
}
|
|
if org == "" {
|
|
org = "core"
|
|
}
|
|
|
|
issue := parseIntString(issueValue)
|
|
|
|
core.Print(nil, "core-agent %s", commandLabel)
|
|
core.Print(nil, " repo: %s/%s", org, repo)
|
|
core.Print(nil, " agent: %s", agent)
|
|
if issue > 0 {
|
|
core.Print(nil, " issue: #%d", issue)
|
|
}
|
|
core.Print(nil, " task: %s", task)
|
|
core.Print(nil, "")
|
|
|
|
result := s.DispatchSync(ctx, DispatchSyncInput{
|
|
Org: org, Repo: repo, Agent: agent, Task: task, Issue: issue,
|
|
})
|
|
|
|
if !result.OK {
|
|
failureError := result.Error
|
|
if failureError == nil {
|
|
failureError = core.E(errorName, "dispatch failed", nil)
|
|
}
|
|
core.Print(nil, "FAILED: %v", failureError)
|
|
return core.Result{Value: failureError, OK: false}
|
|
}
|
|
|
|
core.Print(nil, "DONE: %s", result.Status)
|
|
if result.PRURL != "" {
|
|
core.Print(nil, " PR: %s", result.PRURL)
|
|
}
|
|
return core.Result{OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdOrchestrator(_ core.Options) core.Result {
|
|
return s.runDispatchLoop("orchestrator")
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdDispatch(_ core.Options) core.Result {
|
|
return s.runDispatchLoop("dispatch")
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdDispatchStart(_ core.Options) core.Result {
|
|
_, output, err := s.dispatchStart(s.commandContext(), nil, ShutdownInput{})
|
|
if err != nil {
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
if output.Message != "" {
|
|
core.Print(nil, "%s", output.Message)
|
|
}
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdDispatchShutdown(_ core.Options) core.Result {
|
|
_, output, err := s.shutdownGraceful(s.commandContext(), nil, ShutdownInput{})
|
|
if err != nil {
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
if output.Message != "" {
|
|
core.Print(nil, "%s", output.Message)
|
|
}
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdDispatchShutdownNow(_ core.Options) core.Result {
|
|
_, output, err := s.shutdownNow(s.commandContext(), nil, ShutdownInput{})
|
|
if err != nil {
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
if output.Message != "" {
|
|
core.Print(nil, "%s", output.Message)
|
|
}
|
|
if output.Running > 0 || output.Queued > 0 {
|
|
core.Print(nil, "running: %d", output.Running)
|
|
core.Print(nil, "queued: %d", output.Queued)
|
|
}
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdPoke(_ core.Options) core.Result {
|
|
s.Poke()
|
|
core.Print(nil, "queue poke requested")
|
|
return core.Result{OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) runDispatchLoop(label string) core.Result {
|
|
ctx := s.commandContext()
|
|
core.Print(nil, "core-agent %s running (pid %s)", label, core.Env("PID"))
|
|
core.Print(nil, " workspace: %s", WorkspaceRoot())
|
|
core.Print(nil, " watching queue, draining on 30s tick + completion poke")
|
|
|
|
<-ctx.Done()
|
|
core.Print(nil, "%s shutting down", label)
|
|
return core.Result{OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdPrep(options core.Options) core.Result {
|
|
repo := options.String("_arg")
|
|
if repo == "" {
|
|
core.Print(nil, "usage: core-agent prep <repo> --issue=N|--pr=N|--branch=X --task=\"...\" [--plan-template=bug-fix] [--variables='{\"key\":\"value\"}']")
|
|
return core.Result{Value: core.E("agentic.cmdPrep", "repo is required", nil), OK: false}
|
|
}
|
|
|
|
prepInput := prepInputFromCommandOptions(options)
|
|
prepInput.Repo = repo
|
|
|
|
if prepInput.Issue == 0 && prepInput.PR == 0 && prepInput.Branch == "" && prepInput.Tag == "" {
|
|
prepInput.Branch = "dev"
|
|
}
|
|
|
|
_, prepOutput, err := s.PrepareWorkspace(context.Background(), prepInput)
|
|
if err != nil {
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
core.Print(nil, "workspace: %s", prepOutput.WorkspaceDir)
|
|
core.Print(nil, "repo: %s", prepOutput.RepoDir)
|
|
core.Print(nil, "branch: %s", prepOutput.Branch)
|
|
if prepOutput.PromptVersion != "" {
|
|
core.Print(nil, "prompt: %s", prepOutput.PromptVersion)
|
|
}
|
|
core.Print(nil, "resumed: %v", prepOutput.Resumed)
|
|
core.Print(nil, "memories: %d", prepOutput.Memories)
|
|
core.Print(nil, "consumers: %d", prepOutput.Consumers)
|
|
if prepOutput.Prompt != "" {
|
|
core.Print(nil, "")
|
|
core.Print(nil, "--- prompt (%d chars) ---", len(prepOutput.Prompt))
|
|
core.Print(nil, "%s", prepOutput.Prompt)
|
|
}
|
|
return core.Result{OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdResume(options core.Options) core.Result {
|
|
workspace := optionStringValue(options, "workspace", "_arg")
|
|
if workspace == "" {
|
|
core.Print(nil, "usage: core-agent resume <workspace> [--answer=\"...\"] [--agent=codex] [--dry-run]")
|
|
return core.Result{Value: core.E("agentic.cmdResume", "workspace is required", nil), OK: false}
|
|
}
|
|
|
|
_, output, err := s.resume(s.commandContext(), nil, ResumeInput{
|
|
Workspace: workspace,
|
|
Answer: optionStringValue(options, "answer"),
|
|
Agent: optionStringValue(options, "agent"),
|
|
DryRun: optionBoolValue(options, "dry_run", "dry-run"),
|
|
})
|
|
if err != nil {
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
core.Print(nil, "workspace: %s", output.Workspace)
|
|
core.Print(nil, "agent: %s", output.Agent)
|
|
if output.PID > 0 {
|
|
core.Print(nil, "pid: %d", output.PID)
|
|
}
|
|
if output.OutputFile != "" {
|
|
core.Print(nil, "output: %s", output.OutputFile)
|
|
}
|
|
if output.Prompt != "" {
|
|
core.Print(nil, "")
|
|
core.Print(nil, "--- prompt (%d chars) ---", len(output.Prompt))
|
|
core.Print(nil, "%s", output.Prompt)
|
|
}
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdGenerate(options core.Options) core.Result {
|
|
prompt := optionStringValue(options, "prompt", "_arg")
|
|
briefID := optionStringValue(options, "brief_id", "brief-id")
|
|
template := optionStringValue(options, "template")
|
|
if prompt == "" && (briefID == "" || template == "") {
|
|
core.Print(nil, "usage: core-agent generate --prompt=\"Draft a release note\" [--brief-id=brief_1 --template=help-article] [--provider=claude] [--config='{\"max_tokens\":4000}']")
|
|
return core.Result{Value: core.E("agentic.cmdGenerate", "prompt or brief-id/template is required", nil), OK: false}
|
|
}
|
|
|
|
result := s.handleContentGenerate(s.commandContext(), core.NewOptions(
|
|
core.Option{Key: "prompt", Value: prompt},
|
|
core.Option{Key: "brief_id", Value: briefID},
|
|
core.Option{Key: "template", Value: template},
|
|
core.Option{Key: "provider", Value: options.String("provider")},
|
|
core.Option{Key: "config", Value: options.String("config")},
|
|
))
|
|
if !result.OK {
|
|
err := commandResultError("agentic.cmdGenerate", result)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
output, ok := result.Value.(ContentGenerateOutput)
|
|
if !ok {
|
|
err := core.E("agentic.cmdGenerate", "invalid content generate output", nil)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
if output.Result.Provider != "" {
|
|
core.Print(nil, "provider: %s", output.Result.Provider)
|
|
}
|
|
if output.Result.Model != "" {
|
|
core.Print(nil, "model: %s", output.Result.Model)
|
|
}
|
|
if output.Result.Status != "" {
|
|
core.Print(nil, "status: %s", output.Result.Status)
|
|
}
|
|
if output.Result.Content != "" {
|
|
core.Print(nil, "content: %s", output.Result.Content)
|
|
}
|
|
if output.Result.InputTokens > 0 || output.Result.OutputTokens > 0 {
|
|
core.Print(nil, "tokens: %d in / %d out", output.Result.InputTokens, output.Result.OutputTokens)
|
|
}
|
|
|
|
return core.Result{OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdContentSchemaGenerate(options core.Options) core.Result {
|
|
schemaType := optionStringValue(options, "schema_type", "schema-type", "type", "kind")
|
|
title := optionStringValue(options, "title", "headline")
|
|
if schemaType == "" || title == "" {
|
|
core.Print(nil, "usage: core-agent content schema generate --type=howto --title=\"Set up the workspace\" [--description=\"...\"] [--url=\"https://example.test/setup\"] [--author=\"Virgil\"] [--questions='[{\"question\":\"...\",\"answer\":\"...\"}]'] [--steps='[{\"name\":\"...\",\"text\":\"...\"}]']")
|
|
return core.Result{Value: core.E("agentic.cmdContentSchemaGenerate", "schema type and title are required", nil), OK: false}
|
|
}
|
|
|
|
result := s.handleContentSchemaGenerate(s.commandContext(), core.NewOptions(
|
|
core.Option{Key: "schema_type", Value: schemaType},
|
|
core.Option{Key: "title", Value: title},
|
|
core.Option{Key: "description", Value: optionStringValue(options, "description")},
|
|
core.Option{Key: "url", Value: optionStringValue(options, "url", "link")},
|
|
core.Option{Key: "author", Value: optionStringValue(options, "author")},
|
|
core.Option{Key: "published_at", Value: optionStringValue(options, "published_at", "published-at", "date_published")},
|
|
core.Option{Key: "modified_at", Value: optionStringValue(options, "modified_at", "modified-at", "date_modified")},
|
|
core.Option{Key: "language", Value: optionStringValue(options, "language", "in_language", "in-language")},
|
|
core.Option{Key: "image", Value: optionStringValue(options, "image", "image_url", "image-url")},
|
|
core.Option{Key: "questions", Value: optionAnyValue(options, "questions", "faq")},
|
|
core.Option{Key: "steps", Value: optionAnyValue(options, "steps")},
|
|
))
|
|
if !result.OK {
|
|
err := commandResultError("agentic.cmdContentSchemaGenerate", result)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
output, ok := result.Value.(ContentSchemaOutput)
|
|
if !ok {
|
|
err := core.E("agentic.cmdContentSchemaGenerate", "invalid content schema output", nil)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
core.Print(nil, "schema type: %s", output.SchemaType)
|
|
core.Print(nil, "schema json: %s", output.SchemaJSON)
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdComplete(options core.Options) core.Result {
|
|
result := s.handleComplete(s.commandContext(), options)
|
|
if !result.OK {
|
|
err := commandResultError("agentic.cmdComplete", result)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdScan(options core.Options) core.Result {
|
|
result := s.handleScan(s.commandContext(), core.NewOptions(
|
|
core.Option{Key: "org", Value: optionStringValue(options, "org")},
|
|
core.Option{Key: "labels", Value: optionStringSliceValue(options, "labels")},
|
|
core.Option{Key: "limit", Value: optionIntValue(options, "limit")},
|
|
))
|
|
if !result.OK {
|
|
err := commandResultError("agentic.cmdScan", result)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
output, ok := result.Value.(ScanOutput)
|
|
if !ok {
|
|
err := core.E("agentic.cmdScan", "invalid scan output", nil)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
core.Print(nil, "count: %d", output.Count)
|
|
for _, issue := range output.Issues {
|
|
if len(issue.Labels) > 0 {
|
|
core.Print(nil, " %s#%d %s [%s]", issue.Repo, issue.Number, issue.Title, core.Join(",", issue.Labels...))
|
|
continue
|
|
}
|
|
core.Print(nil, " %s#%d %s", issue.Repo, issue.Number, issue.Title)
|
|
}
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdMirror(options core.Options) core.Result {
|
|
result := s.handleMirror(s.commandContext(), core.NewOptions(
|
|
core.Option{Key: "repo", Value: optionStringValue(options, "repo", "_arg")},
|
|
core.Option{Key: "dry_run", Value: optionBoolValue(options, "dry_run", "dry-run")},
|
|
core.Option{Key: "max_files", Value: optionIntValue(options, "max_files", "max-files")},
|
|
))
|
|
if !result.OK {
|
|
err := commandResultError("agentic.cmdMirror", result)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
output, ok := result.Value.(MirrorOutput)
|
|
if !ok {
|
|
err := core.E("agentic.cmdMirror", "invalid mirror output", nil)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
core.Print(nil, "count: %d", output.Count)
|
|
for _, item := range output.Synced {
|
|
core.Print(nil, " %s commits=%d files=%d", item.Repo, item.CommitsAhead, item.FilesChanged)
|
|
if item.PRURL != "" {
|
|
core.Print(nil, " pr: %s", item.PRURL)
|
|
}
|
|
if item.Skipped != "" {
|
|
core.Print(nil, " %s", item.Skipped)
|
|
}
|
|
}
|
|
for _, skipped := range output.Skipped {
|
|
core.Print(nil, "skipped: %s", skipped)
|
|
}
|
|
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdBrainList(options core.Options) core.Result {
|
|
result := s.Core().Action("brain.list").Run(s.commandContext(), core.NewOptions(
|
|
core.Option{Key: "project", Value: optionStringValue(options, "project")},
|
|
core.Option{Key: "type", Value: optionStringValue(options, "type")},
|
|
core.Option{Key: "agent_id", Value: optionStringValue(options, "agent_id", "agent")},
|
|
core.Option{Key: "limit", Value: optionIntValue(options, "limit")},
|
|
))
|
|
if !result.OK {
|
|
err := commandResultError("agentic.cmdBrainList", result)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
payload, ok := result.Value.(map[string]any)
|
|
if !ok {
|
|
jsonResult := core.JSONMarshalString(result.Value)
|
|
if jsonResult == "" {
|
|
err := core.E("agentic.cmdBrainList", "invalid brain list output", nil)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
var decoded any
|
|
if parseResult := core.JSONUnmarshalString(jsonResult, &decoded); !parseResult.OK {
|
|
err, _ := parseResult.Value.(error)
|
|
if err == nil {
|
|
err = core.E("agentic.cmdBrainList", "invalid brain list output", nil)
|
|
}
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
payload, ok = decoded.(map[string]any)
|
|
if !ok {
|
|
err := core.E("agentic.cmdBrainList", "invalid brain list output", nil)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
}
|
|
|
|
output := brainListOutputFromPayload(payload)
|
|
core.Print(nil, "count: %d", output.Count)
|
|
if len(output.Memories) == 0 {
|
|
core.Print(nil, "no memories")
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
for _, memory := range output.Memories {
|
|
if memory.Project != "" || memory.AgentID != "" || memory.Confidence != 0 {
|
|
core.Print(nil, " %s %-12s %s %s %.2f", memory.ID, memory.Type, memory.Project, memory.AgentID, memory.Confidence)
|
|
} else {
|
|
core.Print(nil, " %s %-12s", memory.ID, memory.Type)
|
|
}
|
|
if memory.SupersedesCount > 0 {
|
|
core.Print(nil, " supersedes: %d", memory.SupersedesCount)
|
|
}
|
|
if memory.DeletedAt != "" {
|
|
core.Print(nil, " deleted_at: %s", memory.DeletedAt)
|
|
}
|
|
if memory.Content != "" {
|
|
core.Print(nil, " %s", memory.Content)
|
|
}
|
|
}
|
|
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
// result := c.Command("brain/remember").Run(ctx, core.NewOptions(
|
|
//
|
|
// core.Option{Key: "content", Value: "Use named actions."},
|
|
// core.Option{Key: "type", Value: "convention"},
|
|
//
|
|
// ))
|
|
func (s *PrepSubsystem) cmdBrainRemember(options core.Options) core.Result {
|
|
content := optionStringValue(options, "content", "_arg")
|
|
memoryType := optionStringValue(options, "type")
|
|
if core.Trim(content) == "" || memoryType == "" {
|
|
core.Print(nil, "usage: core-agent brain remember <content> --type=observation [--tags=architecture,convention] [--project=agent] [--confidence=0.8] [--supersedes=mem-123] [--expires-in=24]")
|
|
return core.Result{Value: core.E("agentic.cmdBrainRemember", "content and type are required", nil), OK: false}
|
|
}
|
|
|
|
result := s.Core().Action("brain.remember").Run(s.commandContext(), core.NewOptions(
|
|
core.Option{Key: "content", Value: content},
|
|
core.Option{Key: "type", Value: memoryType},
|
|
core.Option{Key: "tags", Value: optionStringSliceValue(options, "tags")},
|
|
core.Option{Key: "project", Value: optionStringValue(options, "project")},
|
|
core.Option{Key: "confidence", Value: optionStringValue(options, "confidence")},
|
|
core.Option{Key: "supersedes", Value: optionStringValue(options, "supersedes")},
|
|
core.Option{Key: "expires_in", Value: optionIntValue(options, "expires_in", "expires-in")},
|
|
))
|
|
if !result.OK {
|
|
err := commandResultError("agentic.cmdBrainRemember", result)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
jsonResult := core.JSONMarshalString(result.Value)
|
|
if jsonResult == "" {
|
|
err := core.E("agentic.cmdBrainRemember", "invalid brain remember output", nil)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
var decoded map[string]any
|
|
if parseResult := core.JSONUnmarshalString(jsonResult, &decoded); !parseResult.OK {
|
|
err := core.E("agentic.cmdBrainRemember", "invalid brain remember output", nil)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
memoryID := stringValue(decoded["memoryId"])
|
|
if memoryID == "" {
|
|
memoryID = stringValue(decoded["memory_id"])
|
|
}
|
|
core.Print(nil, "remembered: %s", memoryID)
|
|
if timestamp := stringValue(decoded["timestamp"]); timestamp != "" {
|
|
core.Print(nil, "timestamp: %s", timestamp)
|
|
}
|
|
return core.Result{Value: decoded, OK: true}
|
|
}
|
|
|
|
// result := c.Command("brain/recall").Run(ctx, core.NewOptions(
|
|
//
|
|
// core.Option{Key: "query", Value: "workspace handoff context"},
|
|
//
|
|
// ))
|
|
func (s *PrepSubsystem) cmdBrainRecall(options core.Options) core.Result {
|
|
query := optionStringValue(options, "query", "_arg")
|
|
if query == "" {
|
|
core.Print(nil, "usage: core-agent brain recall <query> [--top-k=10] [--project=agent] [--type=architecture] [--agent=virgil] [--min-confidence=0.7]")
|
|
return core.Result{Value: core.E("agentic.cmdBrainRecall", "query is required", nil), OK: false}
|
|
}
|
|
|
|
result := s.Core().Action("brain.recall").Run(s.commandContext(), core.NewOptions(
|
|
core.Option{Key: "query", Value: query},
|
|
core.Option{Key: "top_k", Value: optionIntValue(options, "top_k", "top-k")},
|
|
core.Option{Key: "project", Value: optionStringValue(options, "project")},
|
|
core.Option{Key: "type", Value: optionStringValue(options, "type")},
|
|
core.Option{Key: "agent_id", Value: optionStringValue(options, "agent_id", "agent")},
|
|
core.Option{Key: "min_confidence", Value: optionStringValue(options, "min_confidence", "min-confidence")},
|
|
))
|
|
if !result.OK {
|
|
err := commandResultError("agentic.cmdBrainRecall", result)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
output, ok := brainRecallOutputFromResult(result.Value)
|
|
if !ok {
|
|
err := core.E("agentic.cmdBrainRecall", "invalid brain recall output", nil)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
core.Print(nil, "count: %d", output.Count)
|
|
if len(output.Memories) == 0 {
|
|
core.Print(nil, "no memories")
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
for _, memory := range output.Memories {
|
|
if memory.Project != "" || memory.AgentID != "" || memory.Confidence != 0 {
|
|
core.Print(nil, " %s %-12s %s %s %.2f", memory.ID, memory.Type, memory.Project, memory.AgentID, memory.Confidence)
|
|
} else {
|
|
core.Print(nil, " %s %-12s", memory.ID, memory.Type)
|
|
}
|
|
if memory.Content != "" {
|
|
core.Print(nil, " %s", memory.Content)
|
|
}
|
|
}
|
|
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
// result := c.Command("brain/forget").Run(ctx, core.NewOptions(core.Option{Key: "_arg", Value: "mem-1"}))
|
|
func (s *PrepSubsystem) cmdBrainForget(options core.Options) core.Result {
|
|
id := optionStringValue(options, "id", "_arg")
|
|
if id == "" {
|
|
core.Print(nil, "usage: core-agent brain forget <memory-id> [--reason=\"superseded\"]")
|
|
return core.Result{Value: core.E("agentic.cmdBrainForget", "memory id is required", nil), OK: false}
|
|
}
|
|
|
|
result := s.Core().Action("brain.forget").Run(s.commandContext(), core.NewOptions(
|
|
core.Option{Key: "id", Value: id},
|
|
core.Option{Key: "reason", Value: optionStringValue(options, "reason")},
|
|
))
|
|
if !result.OK {
|
|
err := commandResultError("agentic.cmdBrainForget", result)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
core.Print(nil, "forgotten: %s", id)
|
|
if reason := optionStringValue(options, "reason"); reason != "" {
|
|
core.Print(nil, "reason: %s", reason)
|
|
}
|
|
return core.Result{Value: result.Value, OK: true}
|
|
}
|
|
|
|
type brainRecallOutput struct {
|
|
Count int `json:"count"`
|
|
Memories []brainRecallMemory `json:"memories"`
|
|
}
|
|
|
|
type brainRecallMemory struct {
|
|
ID string `json:"id"`
|
|
Type string `json:"type"`
|
|
Content string `json:"content"`
|
|
Project string `json:"project"`
|
|
AgentID string `json:"agent_id"`
|
|
Confidence float64 `json:"confidence"`
|
|
DeletedAt string `json:"deleted_at,omitempty"`
|
|
Tags []string `json:"tags"`
|
|
}
|
|
|
|
func brainRecallOutputFromResult(value any) (brainRecallOutput, bool) {
|
|
switch typed := value.(type) {
|
|
case brainRecallOutput:
|
|
return typed, true
|
|
case *brainRecallOutput:
|
|
if typed == nil {
|
|
return brainRecallOutput{}, false
|
|
}
|
|
return *typed, true
|
|
default:
|
|
jsonResult := core.JSONMarshalString(value)
|
|
if jsonResult == "" {
|
|
return brainRecallOutput{}, false
|
|
}
|
|
var output brainRecallOutput
|
|
if parseResult := core.JSONUnmarshalString(jsonResult, &output); !parseResult.OK {
|
|
return brainRecallOutput{}, false
|
|
}
|
|
return output, true
|
|
}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdStatus(options core.Options) core.Result {
|
|
workspaceRoot := WorkspaceRoot()
|
|
filesystem := s.Core().Fs()
|
|
listResult := filesystem.List(workspaceRoot)
|
|
if !listResult.OK {
|
|
core.Print(nil, "no workspaces found at %s", workspaceRoot)
|
|
return core.Result{OK: true}
|
|
}
|
|
|
|
statusFiles := WorkspaceStatusPaths()
|
|
if len(statusFiles) == 0 {
|
|
core.Print(nil, "no workspaces")
|
|
return core.Result{OK: true}
|
|
}
|
|
|
|
requestedWorkspace := optionStringValue(options, "workspace", "_arg")
|
|
requestedStatus := optionStringValue(options, "status")
|
|
limit := optionIntValue(options, "limit")
|
|
matched := 0
|
|
|
|
for _, sf := range statusFiles {
|
|
workspaceDir := core.PathDir(sf)
|
|
workspaceName := WorkspaceName(workspaceDir)
|
|
if !statusInputMatchesWorkspace(requestedWorkspace, workspaceDir, workspaceName) {
|
|
continue
|
|
}
|
|
|
|
result := ReadStatusResult(workspaceDir)
|
|
workspaceStatus, ok := workspaceStatusValue(result)
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
if !statusInputMatchesStatus(requestedStatus, workspaceStatus.Status) {
|
|
continue
|
|
}
|
|
|
|
core.Print(nil, " %-8s %-8s %-10s %s", workspaceStatus.Status, workspaceStatus.Agent, workspaceStatus.Repo, workspaceName)
|
|
if workspaceStatus.Question != "" {
|
|
core.Print(nil, " question: %s", workspaceStatus.Question)
|
|
}
|
|
matched++
|
|
if limit > 0 && matched >= limit {
|
|
break
|
|
}
|
|
}
|
|
return core.Result{OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdPrompt(options core.Options) core.Result {
|
|
repo := options.String("_arg")
|
|
if repo == "" {
|
|
core.Print(nil, "usage: core-agent prompt <repo> --task=\"...\" [--plan-template=bug-fix] [--variables='{\"key\":\"value\"}']")
|
|
return core.Result{Value: core.E("agentic.cmdPrompt", "repo is required", nil), OK: false}
|
|
}
|
|
|
|
prepInput := prepInputFromCommandOptions(options)
|
|
prepInput.Repo = repo
|
|
if prepInput.Org == "" {
|
|
prepInput.Org = "core"
|
|
}
|
|
if prepInput.Task == "" {
|
|
prepInput.Task = "Review and report findings"
|
|
}
|
|
|
|
repoPath := core.JoinPath(HomeDir(), "Code", prepInput.Org, prepInput.Repo)
|
|
|
|
prompt, memories, consumers := s.BuildPrompt(context.Background(), prepInput, "dev", repoPath)
|
|
core.Print(nil, "memories: %d", memories)
|
|
core.Print(nil, "consumers: %d", consumers)
|
|
core.Print(nil, "")
|
|
core.Print(nil, "%s", prompt)
|
|
return core.Result{OK: true}
|
|
}
|
|
|
|
func prepInputFromCommandOptions(options core.Options) PrepInput {
|
|
commandOptions := core.NewOptions(options.Items()...)
|
|
if commandOptions.String("repo") == "" {
|
|
if repo := optionStringValue(options, "_arg"); repo != "" {
|
|
commandOptions.Set("repo", repo)
|
|
}
|
|
}
|
|
return prepInputFromOptions(commandOptions)
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdPromptVersion(options core.Options) core.Result {
|
|
workspace := optionStringValue(options, "workspace", "_arg")
|
|
if workspace == "" {
|
|
core.Print(nil, "usage: core-agent prompt version <workspace>")
|
|
return core.Result{Value: core.E("agentic.cmdPromptVersion", "workspace is required", nil), OK: false}
|
|
}
|
|
|
|
result := s.handlePromptVersion(s.commandContext(), core.NewOptions(
|
|
core.Option{Key: "workspace", Value: workspace},
|
|
))
|
|
if !result.OK {
|
|
err := commandResultError("agentic.cmdPromptVersion", result)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
output, ok := result.Value.(PromptVersionOutput)
|
|
if !ok {
|
|
err := core.E("agentic.cmdPromptVersion", "invalid prompt version output", nil)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
core.Print(nil, "workspace: %s", output.Workspace)
|
|
core.Print(nil, "hash: %s", output.Snapshot.Hash)
|
|
if output.Snapshot.CreatedAt != "" {
|
|
core.Print(nil, "created: %s", output.Snapshot.CreatedAt)
|
|
}
|
|
core.Print(nil, "chars: %d", len(output.Snapshot.Content))
|
|
return core.Result{Value: output, OK: true}
|
|
}
|
|
|
|
func (s *PrepSubsystem) cmdExtract(options core.Options) core.Result {
|
|
sourcePath := optionStringValue(options, "source", "input", "file")
|
|
templateName := options.String("_arg")
|
|
if templateName == "" {
|
|
templateName = "default"
|
|
}
|
|
target := options.String("target")
|
|
|
|
if sourcePath == "" && fs.Exists(templateName) && fs.IsFile(templateName) {
|
|
sourcePath = templateName
|
|
templateName = ""
|
|
}
|
|
|
|
if sourcePath != "" {
|
|
readResult := fs.Read(sourcePath)
|
|
if !readResult.OK {
|
|
err, _ := readResult.Value.(error)
|
|
if err == nil {
|
|
err = core.E("agentic.cmdExtract", core.Concat("read agent output ", sourcePath), nil)
|
|
}
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
extracted := extractAgentOutputContent(readResult.Value.(string))
|
|
if extracted == "" {
|
|
err := core.E("agentic.cmdExtract", "agent output did not contain extractable content", nil)
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
|
|
if target != "" {
|
|
if writeResult := fs.WriteMode(target, extracted, 0644); !writeResult.OK {
|
|
err, _ := writeResult.Value.(error)
|
|
if err == nil {
|
|
err = core.E("agentic.cmdExtract", core.Concat("write extracted output ", target), nil)
|
|
}
|
|
core.Print(nil, "error: %v", err)
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
core.Print(nil, "written: %s", target)
|
|
} else {
|
|
core.Print(nil, "%s", extracted)
|
|
}
|
|
|
|
return core.Result{Value: extracted, OK: true}
|
|
}
|
|
|
|
if target == "" {
|
|
target = core.JoinPath(WorkspaceRoot(), "test-extract")
|
|
}
|
|
|
|
workspaceData := &lib.WorkspaceData{
|
|
Repo: "test-repo",
|
|
Branch: "dev",
|
|
Task: "test extraction",
|
|
Agent: "codex",
|
|
}
|
|
|
|
core.Print(nil, "extracting template %q to %s", templateName, target)
|
|
if result := lib.ExtractWorkspace(templateName, target, workspaceData); !result.OK {
|
|
if err, ok := result.Value.(error); ok {
|
|
return core.Result{Value: core.E("agentic.cmdExtract", core.Concat("extract workspace template ", templateName), err), OK: false}
|
|
}
|
|
return core.Result{Value: core.E("agentic.cmdExtract", core.Concat("extract workspace template ", templateName), nil), OK: false}
|
|
}
|
|
|
|
filesystem := s.Core().Fs()
|
|
paths := core.PathGlob(core.JoinPath(target, "*"))
|
|
for _, p := range paths {
|
|
name := core.PathBase(p)
|
|
marker := " "
|
|
if filesystem.IsDir(p) {
|
|
marker = "/"
|
|
}
|
|
core.Print(nil, " %s%s", name, marker)
|
|
}
|
|
|
|
core.Print(nil, "done")
|
|
return core.Result{OK: true}
|
|
}
|
|
|
|
func extractAgentOutputContent(content string) string {
|
|
trimmed := core.Trim(content)
|
|
if trimmed == "" {
|
|
return ""
|
|
}
|
|
|
|
if core.HasPrefix(trimmed, "{") || core.HasPrefix(trimmed, "[") {
|
|
return trimmed
|
|
}
|
|
|
|
blocks := core.Split(content, "```")
|
|
for index := 1; index < len(blocks); index += 2 {
|
|
block := core.Trim(blocks[index])
|
|
if block == "" {
|
|
continue
|
|
}
|
|
|
|
lines := core.SplitN(block, "\n", 2)
|
|
if len(lines) == 2 {
|
|
language := core.Trim(lines[0])
|
|
body := core.Trim(lines[1])
|
|
if language != "" && !core.Contains(language, " ") && body != "" {
|
|
block = body
|
|
}
|
|
}
|
|
|
|
block = core.Trim(block)
|
|
if block != "" {
|
|
return block
|
|
}
|
|
}
|
|
|
|
return ""
|
|
}
|
|
|
|
// parseIntString("issue-42") // 42
|
|
func parseIntString(s string) int {
|
|
n := 0
|
|
for _, ch := range s {
|
|
if ch >= '0' && ch <= '9' {
|
|
n = n*10 + int(ch-'0')
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
type FlowRunOutput struct {
|
|
Success bool `json:"success"`
|
|
Source string `json:"source,omitempty"`
|
|
Name string `json:"name,omitempty"`
|
|
Description string `json:"description,omitempty"`
|
|
Steps int `json:"steps,omitempty"`
|
|
ResolvedSteps int `json:"resolved_steps,omitempty"`
|
|
Parsed bool `json:"parsed,omitempty"`
|
|
}
|
|
|
|
type flowDefinition struct {
|
|
Name string `yaml:"name"`
|
|
Description string `yaml:"description"`
|
|
Steps []flowDefinitionStep `yaml:"steps"`
|
|
}
|
|
|
|
type flowDefinitionStep struct {
|
|
Name string `yaml:"name"`
|
|
Run string `yaml:"run"`
|
|
Flow string `yaml:"flow"`
|
|
Agent string `yaml:"agent"`
|
|
Prompt string `yaml:"prompt"`
|
|
Template string `yaml:"template"`
|
|
Timeout string `yaml:"timeout"`
|
|
When string `yaml:"when"`
|
|
Output string `yaml:"output"`
|
|
Gate string `yaml:"gate"`
|
|
Parallel []flowDefinitionStep `yaml:"parallel"`
|
|
}
|
|
|
|
type flowRunDocument struct {
|
|
Source string
|
|
Content string
|
|
Parsed bool
|
|
Definition flowDefinition
|
|
}
|
|
|
|
func readFlowDocument(path string, variables map[string]string) core.Result {
|
|
if readResult := fs.Read(path); readResult.OK {
|
|
content := applyTemplateVariables(readResult.Value.(string), variables)
|
|
definition, err := parseFlowDefinition(content)
|
|
if err != nil {
|
|
if flowInputLooksYaml(path) {
|
|
return core.Result{Value: err, OK: false}
|
|
}
|
|
return core.Result{Value: flowRunDocument{
|
|
Source: path,
|
|
Content: content,
|
|
Parsed: false,
|
|
}, OK: true}
|
|
}
|
|
return core.Result{Value: flowRunDocument{
|
|
Source: path,
|
|
Content: content,
|
|
Parsed: true,
|
|
Definition: definition,
|
|
}, OK: true}
|
|
}
|
|
|
|
flowResult := lib.Flow(flowSlugFromPath(path))
|
|
if !flowResult.OK {
|
|
if err, ok := flowResult.Value.(error); ok {
|
|
return core.Result{Value: core.E("agentic.cmdRunFlow", core.Concat("flow not found: ", path), err), OK: false}
|
|
}
|
|
return core.Result{Value: core.E("agentic.cmdRunFlow", core.Concat("flow not found: ", path), nil), OK: false}
|
|
}
|
|
|
|
content := applyTemplateVariables(flowResult.Value.(string), variables)
|
|
definition, err := parseFlowDefinition(content)
|
|
if err != nil {
|
|
return core.Result{Value: flowRunDocument{
|
|
Source: core.Concat("embedded:", flowSlugFromPath(path)),
|
|
Content: content,
|
|
Parsed: false,
|
|
}, OK: true}
|
|
}
|
|
return core.Result{Value: flowRunDocument{
|
|
Source: core.Concat("embedded:", flowSlugFromPath(path)),
|
|
Content: content,
|
|
Parsed: true,
|
|
Definition: definition,
|
|
}, OK: true}
|
|
}
|
|
|
|
func parseFlowDefinition(content string) (flowDefinition, error) {
|
|
var definition flowDefinition
|
|
if err := yaml.Unmarshal([]byte(content), &definition); err != nil {
|
|
return flowDefinition{}, core.E("agentic.parseFlowDefinition", "invalid flow definition", err)
|
|
}
|
|
if definition.Name == "" || len(definition.Steps) == 0 {
|
|
return flowDefinition{}, core.E("agentic.parseFlowDefinition", "invalid flow definition", nil)
|
|
}
|
|
return definition, nil
|
|
}
|
|
|
|
func flowInputLooksYaml(path string) bool {
|
|
return core.HasSuffix(path, ".yaml") || core.HasSuffix(path, ".yml")
|
|
}
|
|
|
|
func flowSlugFromPath(path string) string {
|
|
slug := core.PathBase(path)
|
|
for _, suffix := range []string{".yaml", ".yml", ".md"} {
|
|
slug = core.TrimSuffix(slug, suffix)
|
|
}
|
|
return slug
|
|
}
|
|
|
|
func flowStepSummary(step flowDefinitionStep) string {
|
|
label := core.Trim(step.Name)
|
|
if label == "" {
|
|
label = core.Trim(step.Flow)
|
|
}
|
|
if label == "" {
|
|
label = core.Trim(step.Agent)
|
|
}
|
|
if label == "" {
|
|
label = core.Trim(step.Run)
|
|
}
|
|
if label == "" {
|
|
label = "step"
|
|
}
|
|
|
|
switch {
|
|
case step.Flow != "":
|
|
return core.Concat(label, ": flow ", step.Flow)
|
|
case step.Agent != "":
|
|
return core.Concat(label, ": agent ", step.Agent)
|
|
case step.Run != "":
|
|
return core.Concat(label, ": run ", step.Run)
|
|
case step.Gate != "":
|
|
return core.Concat(label, ": gate ", step.Gate)
|
|
default:
|
|
return label
|
|
}
|
|
}
|
|
|
|
func (s *PrepSubsystem) printFlowSteps(document flowRunDocument, indent string, variables map[string]string, visited map[string]bool) int {
|
|
total := 0
|
|
for index, step := range document.Definition.Steps {
|
|
core.Print(nil, "%s%d. %s", indent, index+1, flowStepSummary(step))
|
|
total++
|
|
|
|
if step.Flow != "" {
|
|
resolved := s.resolveFlowReference(document.Source, step.Flow, variables)
|
|
if !resolved.OK {
|
|
continue
|
|
}
|
|
|
|
nested, ok := resolved.Value.(flowRunDocument)
|
|
if !ok || nested.Source == "" {
|
|
continue
|
|
}
|
|
if visited[nested.Source] {
|
|
core.Print(nil, "%s cycle: %s", indent, nested.Source)
|
|
continue
|
|
}
|
|
|
|
core.Print(nil, "%s resolved: %s", indent, nested.Source)
|
|
visited[nested.Source] = true
|
|
total += s.printFlowSteps(nested, core.Concat(indent, " "), variables, visited)
|
|
delete(visited, nested.Source)
|
|
}
|
|
|
|
if len(step.Parallel) > 0 {
|
|
core.Print(nil, "%s parallel:", indent)
|
|
for parallelIndex, parallelStep := range step.Parallel {
|
|
core.Print(nil, "%s %d. %s", indent, parallelIndex+1, flowStepSummary(parallelStep))
|
|
}
|
|
}
|
|
}
|
|
|
|
return total
|
|
}
|
|
|
|
func (s *PrepSubsystem) resolveFlowReference(baseSource, reference string, variables map[string]string) core.Result {
|
|
trimmedReference := core.Trim(reference)
|
|
if trimmedReference == "" {
|
|
return core.Result{Value: core.E("agentic.resolveFlowReference", "flow reference is required", nil), OK: false}
|
|
}
|
|
|
|
candidates := []string{trimmedReference}
|
|
|
|
if root := flowRootPath(baseSource); root != "" {
|
|
candidate := core.JoinPath(root, trimmedReference)
|
|
if candidate != trimmedReference {
|
|
candidates = append(candidates, candidate)
|
|
}
|
|
}
|
|
|
|
repoCandidate := core.JoinPath("pkg", "lib", "flow", trimmedReference)
|
|
if repoCandidate != trimmedReference {
|
|
candidates = append(candidates, repoCandidate)
|
|
}
|
|
|
|
for _, candidate := range candidates {
|
|
result := readFlowDocument(candidate, variables)
|
|
if result.OK {
|
|
return result
|
|
}
|
|
|
|
err, ok := result.Value.(error)
|
|
if !ok || !core.Contains(err.Error(), "flow not found:") {
|
|
return result
|
|
}
|
|
}
|
|
|
|
return core.Result{Value: core.E("agentic.resolveFlowReference", core.Concat("flow not found: ", trimmedReference), nil), OK: false}
|
|
}
|
|
|
|
func flowRootPath(source string) string {
|
|
trimmed := core.Trim(core.Replace(source, "\\", "/"))
|
|
if trimmed == "" {
|
|
return ""
|
|
}
|
|
|
|
segments := core.Split(trimmed, "/")
|
|
for index := 0; index+2 < len(segments); index++ {
|
|
if segments[index] == "pkg" && segments[index+1] == "lib" && segments[index+2] == "flow" {
|
|
return core.JoinPath(segments[:index+3]...)
|
|
}
|
|
}
|
|
|
|
dir := core.PathDir(trimmed)
|
|
if dir != "" {
|
|
return dir
|
|
}
|
|
|
|
return ""
|
|
}
|
|
|
|
type brainListOutput struct {
|
|
Count int `json:"count"`
|
|
Memories []brainListOutputEntry `json:"memories"`
|
|
}
|
|
|
|
type brainListOutputEntry struct {
|
|
ID string `json:"id"`
|
|
Type string `json:"type"`
|
|
Content string `json:"content"`
|
|
Project string `json:"project"`
|
|
AgentID string `json:"agent_id"`
|
|
Confidence float64 `json:"confidence"`
|
|
SupersedesCount int `json:"supersedes_count,omitempty"`
|
|
DeletedAt string `json:"deleted_at,omitempty"`
|
|
Tags []string `json:"tags"`
|
|
}
|
|
|
|
func brainListOutputFromPayload(payload map[string]any) brainListOutput {
|
|
output := brainListOutput{}
|
|
switch count := payload["count"].(type) {
|
|
case float64:
|
|
output.Count = int(count)
|
|
case int:
|
|
output.Count = count
|
|
}
|
|
if memories, ok := payload["memories"].([]any); ok {
|
|
for _, item := range memories {
|
|
entryMap, ok := item.(map[string]any)
|
|
if !ok {
|
|
continue
|
|
}
|
|
entry := brainListOutputEntry{
|
|
ID: brainListStringValue(entryMap["id"]),
|
|
Type: brainListStringValue(entryMap["type"]),
|
|
Content: brainListStringValue(entryMap["content"]),
|
|
Project: brainListStringValue(entryMap["project"]),
|
|
AgentID: brainListStringValue(entryMap["agent_id"]),
|
|
}
|
|
switch confidence := entryMap["confidence"].(type) {
|
|
case float64:
|
|
entry.Confidence = confidence
|
|
case int:
|
|
entry.Confidence = float64(confidence)
|
|
}
|
|
if entry.Confidence == 0 {
|
|
switch confidence := entryMap["score"].(type) {
|
|
case float64:
|
|
entry.Confidence = confidence
|
|
case int:
|
|
entry.Confidence = float64(confidence)
|
|
}
|
|
}
|
|
switch supersedesCount := entryMap["supersedes_count"].(type) {
|
|
case float64:
|
|
entry.SupersedesCount = int(supersedesCount)
|
|
case int:
|
|
entry.SupersedesCount = supersedesCount
|
|
}
|
|
entry.DeletedAt = brainListStringValue(entryMap["deleted_at"])
|
|
if tags, ok := entryMap["tags"].([]any); ok {
|
|
for _, tag := range tags {
|
|
entry.Tags = append(entry.Tags, brainListStringValue(tag))
|
|
}
|
|
}
|
|
output.Memories = append(output.Memories, entry)
|
|
}
|
|
}
|
|
if output.Count == 0 {
|
|
output.Count = len(output.Memories)
|
|
}
|
|
return output
|
|
}
|
|
|
|
func brainListStringValue(value any) string {
|
|
switch typed := value.(type) {
|
|
case string:
|
|
return typed
|
|
case int:
|
|
return core.Sprint(typed)
|
|
case int64:
|
|
return core.Sprint(typed)
|
|
case float64:
|
|
return core.Sprint(typed)
|
|
}
|
|
return ""
|
|
}
|