feat(parser): migrate commandcode and iflow providers

Command Code and iFlow both fit the directory JSONL source shape, so moving them together proves the helper against real providers without mixing in nested layouts like Qwen or composite providers like WorkBuddy.

The providers keep source discovery, changed-path classification, persisted lookup, fingerprinting, and parse normalization behind concrete facade implementations while preserving the legacy parser functions for current runtime callers.

Author: mariusvniekerk

internal/parser/commandcode_provider.go

@@ -0,0 +1,155 @@
+package parser
+
+import (
+	"context"
+	"fmt"
+	"path/filepath"
+	"strings"
+)
+
+var _ Provider = (*commandCodeProvider)(nil)
+
+type commandCodeProviderFactory struct {
+	def AgentDef
+}
+
+func newCommandCodeProviderFactory(def AgentDef) ProviderFactory {
+	return commandCodeProviderFactory{def: cloneAgentDef(def)}
+}
+
+func (f commandCodeProviderFactory) Definition() AgentDef {
+	return cloneAgentDef(f.def)
+}
+
+func (f commandCodeProviderFactory) Capabilities() Capabilities {
+	return commandCodeProviderCapabilities()
+}
+
+func (f commandCodeProviderFactory) NewProvider(cfg ProviderConfig) Provider {
+	cfg = cfg.Clone()
+	return &commandCodeProvider{
+		ProviderBase: ProviderBase{
+			Def:    cloneAgentDef(f.def),
+			Caps:   commandCodeProviderCapabilities(),
+			Config: cfg,
+		},
+		sources: newCommandCodeSourceSet(cfg.Roots),
+	}
+}
+
+type commandCodeProvider struct {
+	ProviderBase
+	sources DirectoryJSONLSourceSet
+}
+
+func (p *commandCodeProvider) Discover(ctx context.Context) ([]SourceRef, error) {
+	return p.sources.Discover(ctx)
+}
+
+func (p *commandCodeProvider) WatchPlan(ctx context.Context) (WatchPlan, error) {
+	return p.sources.WatchPlan(ctx)
+}
+
+func (p *commandCodeProvider) SourcesForChangedPath(
+	ctx context.Context,
+	req ChangedPathRequest,
+) ([]SourceRef, error) {
+	return p.sources.SourcesForChangedPath(ctx, req)
+}
+
+func (p *commandCodeProvider) FindSource(
+	ctx context.Context,
+	req FindSourceRequest,
+) (SourceRef, bool, error) {
+	return p.sources.FindSource(ctx, providerFindRequestWithRawSessionID(p.Def, req))
+}
+
+func (p *commandCodeProvider) Fingerprint(
+	ctx context.Context,
+	source SourceRef,
+) (SourceFingerprint, error) {
+	return p.sources.Fingerprint(ctx, source)
+}
+
+func (p *commandCodeProvider) Parse(
+	ctx context.Context,
+	req ParseRequest,
+) (ParseOutcome, error) {
+	if err := ctx.Err(); err != nil {
+		return ParseOutcome{}, err
+	}
+	path, ok := p.sources.pathFromSource(req.Source)
+	if !ok {
+		return ParseOutcome{}, fmt.Errorf("commandcode source path unavailable")
+	}
+	machine := firstNonEmptyJSONLString(req.Machine, p.Config.Machine)
+	sess, msgs, err := ParseCommandCodeSession(path, machine)
+	if err != nil {
+		return ParseOutcome{}, err
+	}
+	if sess == nil {
+		return ParseOutcome{
+			ResultSetComplete: true,
+			SkipReason:        SkipNoSession,
+		}, nil
+	}
+	if req.Fingerprint.Hash != "" {
+		sess.File.Hash = req.Fingerprint.Hash
+	}
+	return ParseOutcome{
+		Results: []ParseResultOutcome{{
+			Result: ParseResult{
+				Session:  *sess,
+				Messages: msgs,
+			},
+			DataVersion: DataVersionCurrent,
+		}},
+		ResultSetComplete: true,
+	}, nil
+}
+
+func newCommandCodeSourceSet(roots []string) DirectoryJSONLSourceSet {
+	return NewDirectoryJSONLSourceSet(
+		AgentCommandCode,
+		roots,
+		JSONLSourceSetOptions{
+			IncludePath:       isCommandCodeSourcePath,
+			ProjectHint:       func(root, path string) string { return "" },
+			SessionIDFromPath: commandCodeSessionIDFromPath,
+		},
+	)
+}
+
+func isCommandCodeSourcePath(root, path string) bool {
+	name := filepath.Base(path)
+	if !strings.HasSuffix(name, ".jsonl") ||
+		strings.HasSuffix(name, ".checkpoints.jsonl") ||
+		strings.HasSuffix(name, ".prompts.jsonl") {
+		return false
+	}
+	return IsValidSessionID(strings.TrimSuffix(name, ".jsonl"))
+}
+
+func commandCodeSessionIDFromPath(root, path string) string {
+	name := filepath.Base(path)
+	if !isCommandCodeSourcePath(root, path) {
+		return ""
+	}
+	return strings.TrimSuffix(name, ".jsonl")
+}
+
+func commandCodeProviderCapabilities() Capabilities {
+	return Capabilities{
+		Source: jsonlFileProviderSourceCapabilities(),
+		Content: ContentCapabilities{
+			FirstMessage:       CapabilitySupported,
+			SessionName:        CapabilitySupported,
+			Cwd:                CapabilitySupported,
+			GitBranch:          CapabilitySupported,
+			Thinking:           CapabilitySupported,
+			ToolCalls:          CapabilitySupported,
+			ToolResults:        CapabilitySupported,
+			MalformedLineCount: CapabilitySupported,
+		},
+	}
+}

internal/parser/commandcode_provider_test.go

@@ -0,0 +1,107 @@
+package parser
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCommandCodeProviderFactoryReplacesLegacyAdapter(t *testing.T) {
+	factory, ok := ProviderFactoryByType(AgentCommandCode)
+	require.True(t, ok)
+	_, legacyFactory := factory.(legacyProviderFactory)
+	assert.False(t, legacyFactory)
+
+	provider, ok := NewProvider(AgentCommandCode, ProviderConfig{
+		Roots:   []string{t.TempDir()},
+		Machine: "devbox",
+	})
+	require.True(t, ok)
+	_, legacyProvider := provider.(*legacyProvider)
+	assert.False(t, legacyProvider)
+}
+
+func TestCommandCodeProviderSourceMethods(t *testing.T) {
+	root := t.TempDir()
+	projectDir := filepath.Join(root, "users-alice-code-sample-project")
+	sourcePath := filepath.Join(projectDir, "sess_123.jsonl")
+	writeSourceFile(t, sourcePath, commandCodeProviderFixture())
+	writeSourceFile(t, filepath.Join(projectDir, "sess_123.checkpoints.jsonl"), "{}\n")
+	writeSourceFile(t, filepath.Join(projectDir, "sess_123.prompts.jsonl"), "{}\n")
+
+	provider, ok := NewProvider(AgentCommandCode, ProviderConfig{
+		Roots:   []string{root},
+		Machine: "devbox",
+	})
+	require.True(t, ok)
+
+	discovered, err := provider.Discover(context.Background())
+	require.NoError(t, err)
+	require.Len(t, discovered, 1)
+	assert.Equal(t, AgentCommandCode, discovered[0].Provider)
+	assert.Equal(t, sourcePath, discovered[0].DisplayPath)
+	assert.Empty(t, discovered[0].ProjectHint)
+
+	found, ok, err := provider.FindSource(context.Background(), FindSourceRequest{
+		FullSessionID: "host~commandcode:sess_123",
+	})
+	require.NoError(t, err)
+	require.True(t, ok)
+	assert.Equal(t, sourcePath, found.DisplayPath)
+
+	found, ok, err = provider.FindSource(context.Background(), FindSourceRequest{
+		FingerprintKey: sourcePath,
+	})
+	require.NoError(t, err)
+	require.True(t, ok)
+	assert.Equal(t, sourcePath, found.DisplayPath)
+
+	require.NoError(t, os.Remove(sourcePath))
+	changed, err := provider.SourcesForChangedPath(
+		context.Background(),
+		ChangedPathRequest{Path: sourcePath, EventKind: "remove", WatchRoot: root},
+	)
+	require.NoError(t, err)
+	require.Len(t, changed, 1)
+	assert.Equal(t, sourcePath, changed[0].DisplayPath)
+}
+
+func TestCommandCodeProviderParse(t *testing.T) {
+	root := t.TempDir()
+	sourcePath := filepath.Join(root, "project", "sess_123.jsonl")
+	writeSourceFile(t, sourcePath, commandCodeProviderFixture())
+
+	provider, ok := NewProvider(AgentCommandCode, ProviderConfig{
+		Roots:   []string{root},
+		Machine: "devbox",
+	})
+	require.True(t, ok)
+	sources, err := provider.Discover(context.Background())
+	require.NoError(t, err)
+	require.Len(t, sources, 1)
+
+	outcome, err := provider.Parse(context.Background(), ParseRequest{
+		Source: sources[0],
+		Fingerprint: SourceFingerprint{
+			Key:  sourcePath,
+			Hash: "abc123",
+		},
+	})
+	require.NoError(t, err)
+	require.True(t, outcome.ResultSetComplete)
+	require.Len(t, outcome.Results, 1)
+	assert.Equal(t, DataVersionCurrent, outcome.Results[0].DataVersion)
+	assert.Equal(t, "commandcode:sess_123", outcome.Results[0].Result.Session.ID)
+	assert.Equal(t, "devbox", outcome.Results[0].Result.Session.Machine)
+	assert.Equal(t, "abc123", outcome.Results[0].Result.Session.File.Hash)
+	assert.Len(t, outcome.Results[0].Result.Messages, 2)
+}
+
+func commandCodeProviderFixture() string {
+	return `{"id":"m1","timestamp":"2026-06-01T10:00:00Z","sessionId":"sess_123","role":"user","content":[{"type":"text","text":"Inspect server logs"}],"gitBranch":"feature/command-code","metadata":{"version":2,"cwd":"/Users/alice/code/sample-project"}}
+{"id":"m2","timestamp":"2026-06-01T10:00:03Z","sessionId":"sess_123","role":"assistant","content":[{"type":"text","text":"The error is in the startup path."}],"gitBranch":"feature/command-code","metadata":{"version":2}}`
+}

internal/parser/directory_jsonl_source_set.go

@@ -31,7 +31,7 @@ func NewDirectoryJSONLSourceSet(
 	}
 	if options.ProjectHint == nil {
 		options.ProjectHint = func(root, path string) string {
-			return filepath.Base(filepath.Dir(path))
+			return directoryJSONLProjectFromPath(path)
 		}
 	}
 	return DirectoryJSONLSourceSet{
@@ -49,3 +49,7 @@ func isDirectoryJSONLPath(root, path string) bool {
 		parts[0] != "" && parts[0] != "." && parts[0] != ".." &&
 		parts[1] != "" && parts[1] != "." && parts[1] != ".."
 }
+
+func directoryJSONLProjectFromPath(path string) string {
+	return filepath.Base(filepath.Dir(path))
+}