Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

11.8 KB
Raw Blame
package clinesession

import (
	"crypto/sha1"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"path"
	"path/filepath"
	"strings"
	"time"

	"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/schema"
	"github.com/asymptote-labs/agent-beacon/pkg/asymptoteobserve"
)

type MappedEvent struct {
	SourceOrder int
	Event       schema.Event
}

type MapOptions struct {
	MinOrder    int
	SkipStarted bool
}

func MapTrace(ref TraceRef, records []Record, opts MapOptions) []MappedEvent {
	m := &mapper{ref: ref, opts: opts}
	if !opts.SkipStarted {
		m.emitSessionStarted()
	}
	for i := range records {
		m.consume(records[i])
	}
	return m.out
}

type mapper struct {
	ref  TraceRef
	opts MapOptions
	out  []MappedEvent
}

func (m *mapper) consume(record Record) {
	if record.Order <= m.opts.MinOrder {
		return
	}
	switch record.Type {
	case "user_message":
		m.emitPrompt(record)
	case "agent_text":
		m.emitAgentMessage(record)
	case "agent_reasoning":
		m.emitReasoning(record)
	case "tool_call":
		m.emitToolCall(record)
	case "tool_result":
		m.emitToolResult(record)
	}
}

func (m *mapper) base(record Record, action, category string, severity schema.Severity, message string) schema.Event {
	ev := schema.NewEvent(schema.NewEventOptions{
		Action:   action,
		Category: category,
		Severity: severity,
		Fidelity: schema.FidelityObserved,
		Message:  message,
		Origin:   schema.OriginLocal,
		Harness:  schema.HarnessInfo{Name: Harness, CollectionMethod: schema.CollectionMethodPoll},
	})
	if record.TimestampMS > 0 {
		ev.Timestamp = schema.FormatTimestamp(time.UnixMilli(record.TimestampMS))
	} else if m.ref.UpdatedAtUnixMS > 0 {
		ev.Timestamp = schema.FormatTimestamp(time.UnixMilli(m.ref.UpdatedAtUnixMS))
	}
	ev.Session = &schema.SessionInfo{ID: m.ref.ID, WorkingDirectory: m.ref.Directory}
	if record.ModelID != "" {
		ev.Model = asymptoteobserve.NormalizeModelName(record.ModelID)
	}
	return ev
}

func (m *mapper) emitSessionStarted() {
	record := Record{Order: 0, TimestampMS: m.ref.UpdatedAtUnixMS}
	ev := m.base(record, "session.started", "session", schema.SeverityInfo, "Cline session discovered")
	ev.Raw = map[string]interface{}{"cline": map[string]interface{}{"source_path": m.ref.SourcePath, "source_kind": m.ref.Kind}}
	if m.ref.RelatedTo != "" {
		ev.Raw["cline"].(map[string]interface{})["related_to"] = m.ref.RelatedTo
	}
	m.append(record, "session.started", ev)
}

func (m *mapper) emitPrompt(record Record) {
	text := strings.TrimSpace(record.Content)
	if text == "" {
		return
	}
	ev := m.base(record, "prompt.submitted", "prompt", schema.SeverityInfo, "Cline prompt submitted")
	ev.Prompt = &schema.PromptInfo{Text: text}
	ev.Content = asymptoteobserve.RetainedContent(text, asymptoteobserve.DefaultStringLimit)
	ev.GenAI = &schema.GenAIInfo{Input: &schema.GenAIInputInfo{Messages: asymptoteobserve.TextInputMessages(text)}}
	ev.Raw = m.raw(record)
	m.append(record, "prompt", ev)
	if info, ok := asymptoteobserve.ParseHandoffMarker(text); ok {
		link := m.base(record, "session.handoff", "session", schema.SeverityInfo, "Session continued from a "+info.SourceHarness+" session")
		link.Handoff = &info
		m.append(record, "handoff", link)
	}
}

func (m *mapper) emitAgentMessage(record Record) {
	text := strings.TrimSpace(record.Content)
	if text == "" {
		return
	}
	ev := m.base(record, "agent.message", "session", schema.SeverityInfo, "Cline agent message")
	ev.Content = asymptoteobserve.RetainedContent(text, asymptoteobserve.DefaultRawStringLimit)
	ev.GenAI = &schema.GenAIInfo{Output: &schema.GenAIOutputInfo{Messages: asymptoteobserve.TextOutputMessages(text)}}
	applyUsage(&ev, record.Tokens)
	ev.Raw = m.raw(record)
	m.append(record, "assistant", ev)
}

func (m *mapper) emitReasoning(record Record) {
	text := strings.TrimSpace(record.Content)
	if text == "" {
		return
	}
	ev := m.base(record, "agent.reasoning", "reasoning", schema.SeverityInfo, "Cline agent reasoning")
	ev.Content = asymptoteobserve.RetainedContent(text, asymptoteobserve.DefaultRawStringLimit)
	ev.GenAI = &schema.GenAIInfo{Output: &schema.GenAIOutputInfo{Messages: []interface{}{map[string]interface{}{
		"role": "assistant",
		"parts": []interface{}{map[string]interface{}{
			"type":    "reasoning",
			"content": text,
		}},
	}}}}
	applyUsage(&ev, record.Tokens)
	ev.Raw = m.raw(record)
	m.append(record, "reasoning", ev)
}

func (m *mapper) emitToolCall(record Record) {
	name := firstNonEmpty(record.ToolName, "unknown")
	ev := m.base(record, "tool.invoked", "tool", schema.SeverityInfo, "Cline tool invoked")
	ev.Tool = &schema.ToolInfo{Name: name}
	applyToolCall(&ev, name, record)
	applyUsage(&ev, record.Tokens)
	ev.Raw = m.raw(record)
	m.append(record, "tool.call", ev)
}

func (m *mapper) emitToolResult(record Record) {
	name := firstNonEmpty(record.ToolName, "unknown")
	action, category, severity, message := classifyTool(name, record)
	ev := m.base(record, action, category, severity, message)
	ev.Tool = &schema.ToolInfo{Name: name}
	applyToolCall(&ev, name, record)
	switch category {
	case "command":
		applyCommand(&ev, record)
	case "file":
		applyFile(&ev, name, record, m.ref.Directory)
	case "mcp":
		ev.MCP = &schema.MCPInfo{Tool: name}
	}
	if record.Status == "error" {
		ev.Error = &schema.ErrorInfo{Type: "tool_error"}
	}
	ev.Raw = m.raw(record)
	m.append(record, "tool.result", ev)
}

func classifyTool(name string, record Record) (action, category string, severity schema.Severity, message string) {
	lower := strings.ToLower(strings.TrimSpace(name))
	switch {
	case lower == "list_files" || lower == "search_files" || lower == "list_code_definition_names":
		return "file.read", "file", schema.SeverityInfo, "Cline file read"
	case toolNameHasToken(lower, "mcp") || lower == "use_mcp_tool" || lower == "access_mcp_resource":
		return "mcp.tool_invoked", "mcp", schema.SeverityInfo, "Cline MCP tool invoked"
	case toolNameHasToken(lower, "command") || toolNameHasToken(lower, "commands") || toolNameHasToken(lower, "bash") || toolNameHasToken(lower, "shell") || toolNameHasToken(lower, "terminal"):
		return "command.executed", "command", schema.SeverityInfo, "Cline command executed"
	case toolNameHasToken(lower, "read"):
		return "file.read", "file", schema.SeverityInfo, "Cline file read"
	case toolNameHasToken(lower, "write") || toolNameHasToken(lower, "edit") || toolNameHasToken(lower, "replace") || toolNameHasToken(lower, "patch") || toolNameHasToken(lower, "create"):
		return "file.modified", "file", schema.SeverityInfo, "Cline file modified"
	case record.Status == "error":
		return "tool.failed", "tool", schema.SeverityHigh, "Cline tool failed"
	default:
		return "tool.completed", "tool", schema.SeverityInfo, "Cline tool completed"
	}
}

func applyToolCall(ev *schema.Event, name string, record Record) {
	call := &schema.GenAIToolCallInfo{ID: record.CallID}
	if len(record.Args) > 0 {
		call.Arguments = record.Args
	}
	if record.Type == "tool_result" {
		if record.Output != nil {
			call.Result = record.Output
		} else if record.OutputText != "" {
			call.Result = record.OutputText
		}
	}
	ev.GenAI = ensureGenAI(ev.GenAI)
	ev.GenAI.Operation = &schema.GenAIOperationInfo{Name: "execute_tool"}
	ev.GenAI.Tool = &schema.GenAIToolInfo{Name: name, Call: call}
	if path := argString(record.Args, "path", "file_path", "filePath", "target_file", "targetFile"); path != "" {
		ev.Tool.Path = path
	}
	if command := argString(record.Args, "command", "cmd"); command != "" {
		ev.Tool.Command = command
	}
}

func applyCommand(ev *schema.Event, record Record) {
	command := ""
	if ev.Tool != nil {
		command = ev.Tool.Command
	}
	info := &schema.CommandInfo{Command: command}
	if out := strings.TrimSpace(record.OutputText); out != "" {
		info.Output = out
		ev.Content = asymptoteobserve.RetainedContent(out, asymptoteobserve.DefaultStringLimit)
	}
	ev.Command = info
}

func applyFile(ev *schema.Event, name string, record Record, root string) {
	pathValue := ""
	if ev.Tool != nil {
		pathValue = ev.Tool.Path
	}
	if pathValue == "" {
		return
	}
	pathValue = clineWorkspacePath(pathValue, root)
	operation := clineFileOperation(name)
	if operation == "" {
		return
	}
	ev.File = &schema.FileInfo{Path: pathValue, Operation: operation, Language: fileLanguage(pathValue)}
	if ev.Tool != nil {
		ev.Tool.Path = pathValue
	}
}

func applyUsage(ev *schema.Event, usage *TokenUsage) {
	if usage == nil {
		return
	}
	info := &schema.GenAIUsageInfo{}
	if usage.Input > 0 {
		value := usage.Input
		info.InputTokens = &value
	}
	if usage.Output > 0 {
		value := usage.Output
		info.OutputTokens = &value
	}
	if usage.CacheRead > 0 {
		value := usage.CacheRead
		info.CacheRead = &schema.GenAIUsageCacheReadInfo{InputTokens: &value}
	}
	if usage.CacheWrite > 0 {
		value := usage.CacheWrite
		info.CacheCreation = &schema.GenAIUsageCacheCreationInfo{InputTokens: &value}
	}
	if usage.Reasoning > 0 {
		value := usage.Reasoning
		info.Reasoning = &schema.GenAIUsageReasoningInfo{OutputTokens: &value}
	}
	if usage.CostUSD > 0 {
		value := usage.CostUSD
		info.CostUSD = &value
	}
	ev.GenAI = ensureGenAI(ev.GenAI)
	ev.GenAI.Usage = info
}

func (m *mapper) append(record Record, suffix string, ev schema.Event) {
	ev.Event.ID = deterministicEventID(m.ref, record.Order, suffix)
	m.out = append(m.out, MappedEvent{SourceOrder: record.Order, Event: ev})
}

func (m *mapper) raw(record Record) map[string]interface{} {
	return map[string]interface{}{"cline": map[string]interface{}{
		"source_path": m.ref.SourcePath,
		"source_kind": m.ref.Kind,
		"record":      record.Raw,
	}}
}

func deterministicEventID(ref TraceRef, order int, suffix string) string {
	h := sha1.Sum([]byte(fmt.Sprintf("cline:%s:%s:%d:%s", ref.Kind, ref.ID, order, suffix)))
	return hex.EncodeToString(h[:])
}

func ensureGenAI(info *schema.GenAIInfo) *schema.GenAIInfo {
	if info != nil {
		return info
	}
	return &schema.GenAIInfo{}
}

func argString(args map[string]interface{}, keys ...string) string {
	for _, key := range keys {
		if value := stringValue(args[key]); value != "" {
			return value
		}
	}
	return ""
}

func outputString(value interface{}) string {
	if text := stringValue(value); text != "" {
		return text
	}
	data, err := json.Marshal(value)
	if err != nil || len(data) == 0 || string(data) == "null" {
		return ""
	}
	return string(data)
}

func toolNameHasToken(name, token string) bool {
	parts := strings.FieldsFunc(strings.ToLower(name), func(r rune) bool {
		return !(r >= 'a' && r <= 'z' || r >= '0' && r <= '9')
	})
	for _, part := range parts {
		if part == token {
			return true
		}
	}
	return false
}

func clineFileOperation(name string) string {
	lower := strings.ToLower(strings.TrimSpace(name))
	switch lower {
	case "list_files", "search_files", "list_code_definition_names":
		return "read"
	}
	switch {
	case toolNameHasToken(lower, "read") || toolNameHasToken(lower, "view") || toolNameHasToken(lower, "list"):
		return "read"
	case toolNameHasToken(lower, "write") || toolNameHasToken(lower, "create"):
		return "create"
	case toolNameHasToken(lower, "edit") || toolNameHasToken(lower, "replace") || toolNameHasToken(lower, "patch"):
		return "modify"
	default:
		return ""
	}
}

func clineWorkspacePath(value, root string) string {
	value = strings.TrimSpace(value)
	if value == "" || root == "" || isRootedPath(value) {
		return value
	}
	separator := "/"
	if strings.Contains(root, "\\") && !strings.Contains(root, "/") {
		separator = "\\"
	}
	volume, rest := splitPathVolume(root)
	joined := path.Join(strings.ReplaceAll(rest, "\\", "/"), strings.ReplaceAll(value, "\\", "/"))
	if separator != "/" {
		joined = strings.ReplaceAll(joined, "/", separator)
	}
	return volume + joined
}

func isRootedPath(value string) bool {
	if value == "" {
		return false
	}
	if value[0] == '/' || value[0] == '\\' {
		return true
	}
	if len(value) >= 3 && value[1] == ':' && (value[2] == '\\' || value[2] == '/') {
		letter := value[0] | 0x20
		return letter >= 'a' && letter <= 'z'
	}
	return filepath.IsAbs(value)
}

func splitPathVolume(value string) (string, string) {
	if len(value) >= 2 && value[1] == ':' {
		return value[:2], value[2:]
	}
	return "", value
}