Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

17.5 KB
Raw Blame
package httpapi

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"

	"agentflow/internal/domain"
	"agentflow/internal/tracker"
)

const (
	clarifyDefaultModel = assistantDefaultModel
)

var (
	tapdURLRe          = regexp.MustCompile(`(?i)https?://(?:www\.)?(?:tapd\.example\.com|tapd\.cn)[^\s<>"')】\]]+`)
	gongfengIssueURLRe = regexp.MustCompile(`(?i)https?://git\.example\.com/[^\s<>"')】\]]+/issues/\d+`)
)

func clarifyAllowedModel(id string) string {
	return assistantAllowedModel(id, assistantKnownCatalog())
}

// errClarifyNeedsCodeBuddy is returned when a clarification asks for a model of
// another CLI: clarification runs on CodeBuddy only, so a "codex:…" id must be
// refused instead of being swapped for the CodeBuddy default.
var errClarifyNeedsCodeBuddy = errors.New("需求澄清目前只支持 CodeBuddy 模型,请在模型列表中改选 CodeBuddy 模型")

// clarifyModelEngineError reports whether id names a model of a CLI that
// requirement clarification cannot run.
func clarifyModelEngineError(id string) error {
	if engine, _ := assistantModelEngine(id); engine != assistantEngineCodeBuddy {
		return errClarifyNeedsCodeBuddy
	}
	return nil
}

func asStringKeyMap(v any) map[string]any {
	m, ok := v.(map[string]any)
	if !ok || m == nil {
		return map[string]any{}
	}
	return m
}

func stringifyTAPDIDs(v any) map[string]any {
	m := asStringKeyMap(v)
	if len(m) == 0 {
		return m
	}
	for key, val := range m {
		if nested, ok := val.(map[string]any); ok {
			m[key] = stringifyTAPDIDs(nested)
			continue
		}
		if tapdIDArgument(key) {
			m[key] = stringifyJSONID(val)
		}
	}
	return m
}

func tapdIDArgument(key string) bool {
	switch strings.ToLower(strings.TrimSpace(key)) {
	case "id", "workspace_id", "entry_id", "iteration_id", "story_id", "bug_id", "task_id", "entity_id", "docid", "pageid", "issue_id", "project_id":
		return true
	default:
		return false
	}
}

func stringifyJSONID(v any) string {
	switch t := v.(type) {
	case nil:
		return ""
	case string:
		return strings.TrimSpace(t)
	case json.Number:
		return strings.TrimSpace(t.String())
	case json.RawMessage:
		s := strings.TrimSpace(string(t))
		s = strings.Trim(s, `"`)
		return s
	case float64:
		return strconv.FormatInt(int64(t), 10)
	case int:
		return strconv.Itoa(t)
	case int64:
		return strconv.FormatInt(t, 10)
	default:
		return strings.TrimSpace(fmt.Sprint(t))
	}
}

func stripClarifyMCPCalls(parsed any) any {
	raw, ok := parsed.(map[string]any)
	if !ok || raw == nil {
		return parsed
	}
	delete(raw, "mcpCalls")
	return raw
}

func classifyClarifyMCP(item domain.MCPServerDefinition) string {
	mid := strings.ToLower(strings.TrimSpace(item.MarketID))
	blob := strings.ToLower(item.Name + " " + item.ID + " " + mid)
	switch {
	case mid == "70" || mid == "tapd" || strings.Contains(blob, "tapd"):
		return "tapd"
	case mid == "61" || mid == "gongfeng" || strings.Contains(blob, "gongfeng") || strings.Contains(blob, "工蜂"):
		return "gongfeng"
	default:
		return "other"
	}
}

func (h *streamHandlers) clarifyHTTPMCPs(projectID string, userID int64) []domain.MCPServerDefinition {
	if h == nil || h.repo == nil {
		return nil
	}
	out := []domain.MCPServerDefinition{}
	for _, item := range assistantOutboundMCPServers(h.repo.MCPServers(), projectID, userID) {
		transport := strings.ToLower(strings.TrimSpace(item.Transport))
		if transport == "" && strings.TrimSpace(item.URL) != "" {
			transport = "http"
		}
		if transport != "http" && transport != "sse" {
			continue
		}
		out = append(out, item)
	}
	return out
}

func clarifyTAPDWorkspace(issue domain.Issue, project domain.Project) string {
	if issue.ExternalRef != nil {
		if ref, err := tracker.ParseTAPDStoryURL(strings.TrimSpace(issue.ExternalRef.ExternalURL)); err == nil && strings.TrimSpace(ref.WorkspaceID) != "" {
			return ref.WorkspaceID
		}
	}
	return strings.TrimSpace(project.TAPDWorkspaceID)
}

func clarifyTAPDEntry(issue domain.Issue) (entryType, entryID string) {
	if issue.ExternalRef == nil {
		return "", ""
	}
	entryID = strings.TrimSpace(issue.ExternalRef.ExternalID)
	switch strings.ToLower(strings.TrimSpace(issue.ExternalRef.ExternalType)) {
	case "bug":
		return "bug", entryID
	case "task":
		return "task", entryID
	}
	return "story", entryID
}

func (h *streamHandlers) clarifyGongfengProjectID(issue domain.Issue) string {
	if issue.ExternalRef != nil {
		if path := gongfengProjectPathFromClarifyURL(issue.ExternalRef.ExternalURL); path != "" {
			return path
		}
	}
	if h == nil || h.repo == nil {
		return ""
	}
	for _, id := range issue.EffectiveRepositoryIDs() {
		repo, ok := h.repo.Repository(id)
		if ok && strings.TrimSpace(repo.GongfengProjectID) != "" {
			return strings.TrimSpace(repo.GongfengProjectID)
		}
	}
	project, ok := h.repo.Project(issue.ProjectID)
	if !ok || strings.TrimSpace(project.DefaultRepositoryID) == "" {
		return ""
	}
	repo, ok := h.repo.Repository(project.DefaultRepositoryID)
	if !ok {
		return ""
	}
	return strings.TrimSpace(repo.GongfengProjectID)
}

func extractTAPDRefs(texts ...string) []clarifyTAPDHit {
	seen := map[string]bool{}
	var out []clarifyTAPDHit
	for _, text := range texts {
		for _, match := range tapdURLRe.FindAllString(text, -1) {
			raw := strings.TrimRight(match, ".,;:,。;:")
			ref, err := tracker.ParseTAPDStoryURL(raw)
			if err != nil || ref.StoryID == "" || seen[ref.StoryID] {
				continue
			}
			seen[ref.StoryID] = true
			out = append(out, clarifyTAPDHit{Ref: ref, URL: raw})
		}
	}
	return out
}

type clarifyTAPDHit struct {
	Ref tracker.TAPDStoryRef
	URL string
}

type clarifyGongfengHit struct {
	Project string
	IID     int
	URL     string
}

func extractGongfengIssueRefs(texts ...string) []clarifyGongfengHit {
	seen := map[string]bool{}
	var out []clarifyGongfengHit
	for _, text := range texts {
		for _, match := range gongfengIssueURLRe.FindAllString(text, -1) {
			raw := strings.TrimRight(match, ".,;:,。;:")
			project := gongfengProjectPathFromClarifyURL(raw)
			iid := gongfengIssueIIDFromURL(raw)
			key := project + "#" + strconv.Itoa(iid)
			if project == "" || iid <= 0 || seen[key] {
				continue
			}
			seen[key] = true
			out = append(out, clarifyGongfengHit{Project: project, IID: iid, URL: raw})
		}
	}
	return out
}

func gongfengProjectPathFromClarifyURL(raw string) string {
	raw = strings.TrimSpace(raw)
	if raw == "" {
		return ""
	}
	path := raw
	if i := strings.Index(strings.ToLower(raw), "git.example.com/"); i >= 0 {
		path = raw[i+len("git.example.com/"):]
	}
	parts := strings.FieldsFunc(path, func(r rune) bool { return r == '/' })
	for i, part := range parts {
		if !strings.EqualFold(part, "issues") {
			continue
		}
		prefix := parts[:i]
		if n := len(prefix); n > 0 && prefix[n-1] == "-" {
			prefix = prefix[:n-1]
		}
		if len(prefix) >= 2 {
			return strings.Join(prefix, "/")
		}
	}
	return ""
}

func gongfengIssueIIDFromURL(raw string) int {
	raw = strings.TrimRight(strings.TrimSpace(raw), "/")
	i := strings.LastIndex(strings.ToLower(raw), "/issues/")
	if i < 0 {
		return 0
	}
	n, _ := strconv.Atoi(digitsPrefixClarify(raw[i+len("/issues/"):]))
	return n
}

func digitsPrefixClarify(s string) string {
	n := 0
	for n < len(s) && s[n] >= '0' && s[n] <= '9' {
		n++
	}
	return s[:n]
}

func hydrateClarifyIssueFromText(issue *domain.Issue, extras ...string) {
	if issue == nil || issue.ExternalRef != nil {
		return
	}
	texts := append([]string{issue.Title, issue.Description}, extras...)
	if hits := extractTAPDRefs(texts...); len(hits) > 0 {
		hit := hits[0]
		kind := strings.TrimSpace(hit.Ref.Kind)
		if kind == "" {
			kind = "story"
		}
		issue.Source = "tapd"
		issue.ExternalRef = &domain.ExternalRef{Source: "tapd", ExternalID: hit.Ref.StoryID, ExternalType: kind, ExternalURL: hit.URL}
		return
	}
	if hits := extractGongfengIssueRefs(texts...); len(hits) > 0 {
		hit := hits[0]
		issue.Source = "gongfeng"
		issue.ExternalRef = &domain.ExternalRef{Source: "gongfeng", ExternalID: strconv.Itoa(hit.IID), ExternalIID: hit.IID, ExternalType: "issue", ExternalURL: hit.URL}
	}
}

func clarifyRequestTexts(request chatClarifyRequest) []string {
	texts := []string{request.Title, request.Description, request.Message}
	for _, turn := range request.History {
		texts = append(texts, turn.Content)
	}
	return texts
}

func (h *streamHandlers) clarifyMCPInstructions(issue domain.Issue, user domain.User, resumed bool, extras ...string) string {
	return h.clarifyMCPInstructionsFor(issue, user, resumed, extras...)
}

func (h *streamHandlers) clarifyMCPInstructionsFor(issue domain.Issue, user domain.User, resumed bool, extras ...string) string {
	projectID := strings.TrimSpace(issue.ProjectID)
	if projectID == "" {
		return ""
	}
	servers := h.clarifyHTTPMCPs(projectID, user.ID)
	project, _ := h.repo.Project(projectID)
	var tapd, gongfeng []domain.MCPServerDefinition
	var other []domain.MCPServerDefinition
	for _, item := range servers {
		switch classifyClarifyMCP(item) {
		case "tapd":
			tapd = append(tapd, item)
		case "gongfeng":
			gongfeng = append(gongfeng, item)
		default:
			other = append(other, item)
		}
	}
	var b strings.Builder
	b.WriteString("\n\n## 可用工具(只读)\n使用当前项目和个人已安装的 HTTP MCP 以及 agentflow__* 查询原单、评论和文档。stdio MCP 不可用。不要调用写入类工具。资料足够后调用 submit_clarification。\n")
	if len(tapd) > 0 {
		b.WriteString("TAPD 的 id/workspace_id/entry_id 必须是字符串,读取用 tapd__proxy_execute_tool。\n")
	}
	if len(gongfeng) > 0 {
		b.WriteString("代码托管 Issue 用 gongfeng__get_issue_detail、gongfeng__get_issue_notes 读取。\n")
	}
	if len(servers) > 0 {
		b.WriteString("当前项目和个人可用 HTTP MCP:\n")
		for _, item := range servers {
			fmt.Fprintf(&b, "- %s(id=%s", item.Name, item.ID)
			if strings.TrimSpace(item.MarketID) != "" {
				fmt.Fprintf(&b, ", marketId=%s", item.MarketID)
			}
			b.WriteString(")\n")
		}
	}
	if len(tapd) > 0 && strings.EqualFold(strings.TrimSpace(issue.Source), "tapd") {
		b.WriteString(clarifyTAPDReadInstruction(issue, project, resumed))
	}
	if len(gongfeng) > 0 && strings.EqualFold(strings.TrimSpace(issue.Source), "gongfeng") {
		b.WriteString(clarifyGongfengReadInstruction(issue, h.clarifyGongfengProjectID(issue), resumed))
	}
	if issue.ID == "" && issue.ExternalRef == nil && (len(tapd) > 0 || len(gongfeng) > 0) {
		b.WriteString("这是尚未建单的需求草稿,没有原单可拉。描述或对话里出现上述工具能读取的链接时必须先读取后再出题;没有链接不要为了找原单去 list。\n")
	}
	if len(other) > 0 {
		b.WriteString("其他已安装的 HTTP MCP 按工具名直接调用,仅限只读。\n")
	}
	b.WriteString("资料足够后调用 submit_clarification。\n")
	return b.String()
}

// clarifyTAPDReadInstruction tells the clarifier how to read a TAPD-sourced
// issue and its comments via tapd__proxy_execute_tool. A resumed conversation
// already holds the earlier analysis, so it is told not to fetch them again.
func clarifyTAPDReadInstruction(issue domain.Issue, project domain.Project, resumed bool) string {
	entryType, entryID := clarifyTAPDEntry(issue)
	if resumed {
		return fmt.Sprintf("这是 TAPD %s。对话里已有此前分析,不要再重拉原单和评论。仅当出现尚未读取的新文档链接时才用对应 MCP 读取。\n", entryType)
	}
	ws := clarifyTAPDWorkspace(issue, project)
	getTool := "stories_get"
	switch entryType {
	case "bug":
		getTool = "bugs_get"
	case "task":
		getTool = "tasks_get"
	}
	return fmt.Sprintf("这是 TAPD %s。先静默读取原单和评论。调用 tapd__proxy_execute_tool:tool_name=%s,tool_args.workspace_id=%s,tool_args.id=%s(字符串),tool_args.limit=1。评论同样调用该工具,tool_name=comments_get,tool_args.workspace_id=%s,tool_args.entry_type=%s,tool_args.entry_id=%s。不要用 params,必须用 tool_args。\n",
		entryType, getTool, ws, entryID, ws, entryType, entryID)
}

// clarifyGongfengReadInstruction tells the clarifier how to read a
// Gongfeng-sourced issue and its notes. gongfengProject is the project path or
// ID already resolved by the caller.
func clarifyGongfengReadInstruction(issue domain.Issue, gongfengProject string, resumed bool) string {
	if resumed {
		return "这是工蜂 Issue。对话里已有此前分析,不要再重拉原单和评论。\n"
	}
	issueID, issueIID := "", 0
	if issue.ExternalRef != nil {
		issueID = strings.TrimSpace(issue.ExternalRef.ExternalID)
		issueIID = issue.ExternalRef.ExternalIID
	}
	return fmt.Sprintf("这是工蜂 Issue。必须读取原单:调用 gongfeng__get_issue_detail(project_id=%s, issue_iid=%d),并同步 gongfeng__get_issue_notes(project_id=%s, issue_id=%s)看评论。\n",
		gongfengProject, issueIID, gongfengProject, issueID)
}

func clarifyMCPWriteName(name string) bool {
	n := strings.ToLower(strings.TrimSpace(name))
	if n == "" || n == "tools/list" {
		return false
	}
	switch {
	case strings.Contains(n, "create"), strings.Contains(n, "update"), strings.Contains(n, "delete"),
		strings.Contains(n, "save"), strings.Contains(n, "write"), strings.HasPrefix(n, "add_"),
		strings.Contains(n, "move"), strings.Contains(n, "rename"), strings.Contains(n, "copy"):
		return true
	default:
		return false
	}
}

func normalizeClarifyTAPDTool(tool string) string {
	switch strings.TrimSpace(tool) {
	case "comments_list":
		return "comments_get"
	case "stories_list":
		return "stories_get"
	case "bugs_list":
		return "bugs_get"
	case "tasks_list":
		return "tasks_get"
	default:
		return tool
	}
}

func wrapClarifyTAPDCall(call assistantMCPCall) assistantMCPCall {
	tool := normalizeClarifyTAPDTool(call.Tool)
	switch tool {
	case "", "tools/list", "lookup_tapd_tool", "lookup_tool_param_schema", "tql_syntax_reference":
		call.Tool = tool
		call.Arguments = stringifyTAPDIDs(assistantMCPCallArguments(call))
		return call
	}
	args := normalizeTAPDProxyArguments(tool, assistantMCPCallArguments(call))
	call.Tool = "proxy_execute_tool"
	call.Arguments = args
	call.Path, call.Query, call.Body = nil, nil, nil
	return call
}

func normalizeTAPDProxyArguments(tool string, args map[string]any) map[string]any {
	if args == nil {
		args = map[string]any{}
	}
	inner := firstObjectArg(args, "tool_args", "params", "arguments", "input", "args")
	leftovers := map[string]any{}
	for key, val := range args {
		switch strings.ToLower(strings.TrimSpace(key)) {
		case "tool_name", "tool_args", "params", "arguments", "input", "args":
			continue
		default:
			leftovers[key] = val
		}
	}
	if inner == nil {
		inner = leftovers
	} else {
		for key, val := range leftovers {
			if _, ok := inner[key]; !ok {
				inner[key] = val
			}
		}
	}
	name := normalizeClarifyTAPDTool(stringifyJSONID(args["tool_name"]))
	if name == "" && tool != "proxy_execute_tool" {
		name = tool
	}
	out := map[string]any{}
	if name != "" {
		out["tool_name"] = name
	}
	if len(inner) > 0 {
		out["tool_args"] = stringifyTAPDIDs(inner)
	}
	return out
}

func firstObjectArg(args map[string]any, keys ...string) map[string]any {
	for _, key := range keys {
		if nested, ok := args[key].(map[string]any); ok && nested != nil {
			return nested
		}
	}
	return nil
}

func clarifyMCPCallWrite(kind string, call assistantMCPCall) bool {
	if clarifyMCPWriteName(call.Tool) {
		return true
	}
	if kind != "tapd" {
		return false
	}
	args := assistantMCPCallArguments(call)
	inner := strings.TrimSpace(fmt.Sprint(args["tool_name"]))
	if inner == "" {
		return false
	}
	return clarifyMCPWriteName(normalizeClarifyTAPDTool(inner))
}

func (h *streamHandlers) clarifyMCPUser(issue domain.Issue, responsible domain.User) domain.User {
	if h == nil || h.repo == nil {
		return responsible
	}
	project, ok := h.repo.Project(issue.ProjectID)
	if !ok || project.OwnerID <= 0 {
		return responsible
	}
	owner, ok := h.repo.User(project.OwnerID)
	if !ok || len(h.repo.GitHTTPWorkspaceHosts(owner.ID)) == 0 {
		return responsible
	}
	return owner
}

func (h *streamHandlers) dispatchClarifyMCPCall(asst *assistantHandlers, user domain.User, projectID string, call assistantMCPCall, emit func(event string, payload any)) (string, error) {
	if assistantPlatformServer(call.Server) && strings.TrimSpace(call.Tool) != "" && call.Tool != "tools/list" {
		return "", fmt.Errorf("澄清只允许调用当前项目的 HTTP MCP,不能调用平台写入工具")
	}
	server, ok := asst.lookupAssistantMCP(projectID, user.ID, call.Server)
	if !ok {
		return "", fmt.Errorf("当前项目没有名为 %q 的 MCP,或你无权使用", strings.TrimSpace(call.Server))
	}
	kind := classifyClarifyMCP(server)
	if kind == "tapd" {
		call = wrapClarifyTAPDCall(call)
	}
	if clarifyMCPCallWrite(kind, call) {
		name := strings.TrimSpace(call.Tool)
		if kind == "tapd" {
			if inner := strings.TrimSpace(fmt.Sprint(assistantMCPCallArguments(call)["tool_name"])); inner != "" {
				name = inner
			}
		}
		return "", fmt.Errorf("澄清只允许只读 MCP,拒绝 %s", name)
	}
	if emit != nil {
		detail := strings.TrimSpace(call.Tool)
		if kind == "tapd" {
			if inner := strings.TrimSpace(fmt.Sprint(assistantMCPCallArguments(call)["tool_name"])); inner != "" {
				detail = inner
			}
		}
		emit("thought", map[string]string{"kind": "tool", "tool": "MCP", "detail": server.Name + " " + detail})
	}
	caller := user
	if server.Scope != "personal" {
		caller = h.clarifyMCPUser(domain.Issue{ProjectID: projectID}, user)
	}
	return asst.callAssistantMCP(caller, projectID, call)
}

func (h *streamHandlers) openClarifyToolSession(ctx context.Context, user domain.User, issue domain.Issue, cancel context.CancelFunc) (*AgentToolSession, agentToolFiles, error) {
	return startAgentToolSession(ctx, user, issue.ProjectID, AgentToolClarify, assistantExecMode{}, issue.ID, h.clarifyHTTPMCPs(issue.ProjectID, user.ID), cancel, filepath.Join(clarifyCLIHome(user.ID), "mcp-sessions"))
}