@hybridlabor-api/bdb-synapse 1.0.0

package/cmd/synapse/main.go

@@ -0,0 +1,280 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/hybridlabor-api/bdb-synapse/internal/adapter"
+	"github.com/hybridlabor-api/bdb-synapse/internal/adapter/claudecode"
+	"github.com/hybridlabor-api/bdb-synapse/internal/adapter/codex"
+	"github.com/hybridlabor-api/bdb-synapse/internal/adapter/pi"
+	"github.com/hybridlabor-api/bdb-synapse/internal/citymap"
+	"github.com/hybridlabor-api/bdb-synapse/internal/judge"
+	"github.com/hybridlabor-api/bdb-synapse/internal/model"
+	"github.com/hybridlabor-api/bdb-synapse/internal/server"
+)
+
+func main() {
+	if err := run(os.Args[1:]); err != nil {
+		fmt.Fprintln(os.Stderr, "synapse:", err)
+		os.Exit(1)
+	}
+}
+
+func run(args []string) error {
+	if len(args) == 0 {
+		return serve(args)
+	}
+	switch args[0] {
+	case "serve":
+		return serve(args[1:])
+	case "open":
+		return open(args[1:])
+	case "map":
+		return openMap(args[1:])
+	case "build":
+		return build(args[1:])
+	case "trace":
+		return trace(args[1:])
+	case "analyze":
+		return analyze(args[1:])
+	case "-h", "--help", "help":
+		usage()
+		return nil
+	default:
+		return fmt.Errorf("unknown command %q", args[0])
+	}
+}
+
+func serve(args []string) error {
+	fs := flag.NewFlagSet("serve", flag.ExitOnError)
+	port := fs.Int("port", 0, "port to bind on 127.0.0.1")
+	claudeDir := fs.String("claude-dir", claudecode.DefaultDir(), "Claude Code projects directory")
+	codexDir := fs.String("codex-dir", codex.DefaultDir(), "Codex sessions directory")
+	piDir := fs.String("pi-dir", pi.DefaultDir(), "pi sessions directory")
+	agyDir := fs.String("agy-dir", filepath.Join(os.Getenv("HOME"), ".gemini", "antigravity-cli", "brain"), "agy sessions directory")
+	dev := fs.Bool("dev", false, "prefer web/dist from the working tree")
+	noOpen := fs.Bool("no-open", false, "serve without opening a browser")
+	if err := fs.Parse(args); err != nil {
+		return err
+	}
+	return server.New(server.Config{Port: *port, ClaudeDir: *claudeDir, CodexDir: *codexDir, PiDir: *piDir, AgyDir: *agyDir, Dev: *dev}).Start(!*noOpen)
+}
+
+func open(args []string) error {
+	fs := flag.NewFlagSet("open", flag.ExitOnError)
+	port := fs.Int("port", 0, "port to bind on 127.0.0.1")
+	claudeDir := fs.String("claude-dir", claudecode.DefaultDir(), "Claude Code projects directory")
+	codexDir := fs.String("codex-dir", codex.DefaultDir(), "Codex sessions directory")
+	piDir := fs.String("pi-dir", pi.DefaultDir(), "pi sessions directory")
+	agyDir := fs.String("agy-dir", filepath.Join(os.Getenv("HOME"), ".gemini", "antigravity-cli", "brain"), "agy sessions directory")
+	noOpen := fs.Bool("no-open", false, "serve without opening a browser")
+	if err := fs.Parse(args); err != nil {
+		return err
+	}
+	if fs.NArg() != 1 {
+		return fmt.Errorf("usage: synapse open [--no-open] <session.jsonl>")
+	}
+	session, err := filepath.Abs(fs.Arg(0))
+	if err != nil {
+		return err
+	}
+	return server.New(server.Config{Port: *port, ClaudeDir: *claudeDir, CodexDir: *codexDir, PiDir: *piDir, AgyDir: *agyDir, OpenSession: session}).Start(!*noOpen)
+}
+
+func openMap(args []string) error {
+	fs := flag.NewFlagSet("map", flag.ExitOnError)
+	port := fs.Int("port", 0, "port to bind on 127.0.0.1")
+	dev := fs.Bool("dev", false, "prefer web/dist from the working tree")
+	noOpen := fs.Bool("no-open", false, "serve without opening a browser")
+	if err := fs.Parse(args); err != nil {
+		return err
+	}
+	if fs.NArg() != 1 {
+		return fmt.Errorf("usage: synapse map [--no-open] <repo>")
+	}
+	repo, err := filepath.Abs(fs.Arg(0))
+	if err != nil {
+		return err
+	}
+	return server.New(server.Config{Port: *port, Dev: *dev, RepoRoot: repo, MapOnly: true}).Start(!*noOpen)
+}
+
+func build(args []string) error {
+	positional, out, err := parseOutputArgs(args)
+	if err != nil {
+		return err
+	}
+	if len(positional) != 1 {
+		return fmt.Errorf("usage: synapse build <repo> [-o out]")
+	}
+	city, err := citymap.Builder{}.Build(positional[0], nil)
+	if err != nil {
+		return err
+	}
+	return writeJSON(out, city)
+}
+
+func trace(args []string) error {
+	positional, out, err := parseOutputArgs(args)
+	if err != nil {
+		return err
+	}
+	if len(positional) != 1 {
+		return fmt.Errorf("usage: synapse trace <session.jsonl> [-o out]")
+	}
+	tr, err := parseTrace(positional[0])
+	if err != nil {
+		return err
+	}
+	return writeJSON(out, tr)
+}
+
+// judgeMatches reports whether a cached report satisfies an explicit judge
+// choice; unset flags match anything. A model matches on either the
+// canonical name the run recorded (claude-sonnet-5) or the alias it was
+// requested with (sonnet) — so repeating an aliased request hits the cache
+// instead of paying for a fresh run every time.
+func judgeMatches(report *model.Report, cli, modelName string) bool {
+	if cli != "" && report.Judge.CLI != cli {
+		return false
+	}
+	if modelName != "" && report.Judge.Model != modelName && report.Judge.RequestedModel != modelName {
+		return false
+	}
+	return true
+}
+
+func analyze(args []string) error {
+	fs := flag.NewFlagSet("analyze", flag.ExitOnError)
+	out := fs.String("o", "", "write the report to this file instead of stdout")
+	judgeCLI := fs.String("judge", "", "judge CLI to use: claude or codex (default: auto-detect)")
+	judgeModel := fs.String("model", "", "judge model override, e.g. sonnet or gpt-5.6-sol (default: the CLI's default)")
+	noCache := fs.Bool("no-cache", false, "re-run the judge even when a fresh cached report exists")
+	noRubric := fs.Bool("no-rubric", false, "skip the task rubric layer: one dimensions-only judge call, bypassing the report cache")
+	timeout := fs.Duration("timeout", judge.DefaultTimeout, "judge subprocess timeout")
+	// Accept flags after the positional argument, matching trace/build.
+	var positional []string
+	for {
+		if err := fs.Parse(args); err != nil {
+			return err
+		}
+		if fs.NArg() == 0 {
+			break
+		}
+		positional = append(positional, fs.Arg(0))
+		args = fs.Args()[1:]
+	}
+	if len(positional) != 1 {
+		return fmt.Errorf("usage: synapse analyze <session.jsonl> [-o out] [--judge claude|codex] [--model name] [--no-cache] [--no-rubric]")
+	}
+	session, err := filepath.Abs(positional[0])
+	if err != nil {
+		return err
+	}
+	tr, err := parseTrace(session)
+	if err != nil {
+		return err
+	}
+
+	cache := judge.Cache{Dir: judge.DefaultCacheDir()}
+	key := adapter.SessionKey(tr.Session.Harness, session)
+	// --no-cache means a fully fresh run: the cached report is neither
+	// returned nor mined for a reusable rubric. --no-rubric bypasses the
+	// cache in both directions — returning a cached rubric-ful report would
+	// contradict the flag, and storing a rubric-less one would downgrade a
+	// richer cache entry — so the flag always costs one fresh call.
+	var cached *model.Report
+	if !*noCache && !*noRubric {
+		cached = cache.Load(key)
+		// A rubric-enabled request is only answered from cache when the report
+		// already settles the rubric question; a rubric-less fresh report gets
+		// re-run rather than silently returned without the layer.
+		if judge.FreshAgainstTrace(cached, tr) && judgeMatches(cached, *judgeCLI, *judgeModel) &&
+			judge.RubricSatisfied(cached) {
+			fmt.Fprintln(os.Stderr, "synapse: using cached report (pass --no-cache to re-run)")
+			return writeJSON(*out, cached)
+		}
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), *timeout)
+	defer cancel()
+	fmt.Fprintf(os.Stderr, "synapse: judging %d events, this can take a minute or two…\n", tr.Session.EventCount)
+	report, err := judge.Analyze(ctx, tr, judge.Options{CLI: *judgeCLI, Model: *judgeModel, NoRubric: *noRubric, CachedReport: cached})
+	if err != nil {
+		return err
+	}
+	if !*noRubric {
+		if err := cache.Store(key, report); err != nil {
+			fmt.Fprintln(os.Stderr, "synapse: report cache write failed:", err)
+		}
+	}
+	return writeJSON(*out, report)
+}
+
+func parseTrace(path string) (*model.Trace, error) {
+	var lastErr error
+	for _, source := range []adapter.Source{claudecode.Adapter{}, codex.Adapter{}, pi.Adapter{}} {
+		trace, err := source.Parse(path)
+		if err == nil {
+			return trace, nil
+		}
+		lastErr = err
+	}
+	if lastErr != nil {
+		return nil, lastErr
+	}
+	return nil, fmt.Errorf("no session adapters configured")
+}
+
+func parseOutputArgs(args []string) ([]string, string, error) {
+	var out string
+	var positional []string
+	for i := 0; i < len(args); i++ {
+		switch args[i] {
+		case "-o", "--output":
+			i++
+			if i >= len(args) {
+				return nil, "", fmt.Errorf("%s requires a value", args[i-1])
+			}
+			out = args[i]
+		default:
+			positional = append(positional, args[i])
+		}
+	}
+	return positional, out, nil
+}
+
+func writeJSON(out string, v any) error {
+	var f *os.File
+	var err error
+	if out == "" {
+		f = os.Stdout
+	} else {
+		f, err = os.Create(out)
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+	}
+	enc := json.NewEncoder(f)
+	enc.SetIndent("", "  ")
+	return enc.Encode(v)
+}
+
+func usage() {
+	fmt.Println(`synapse
+
+Usage:
+  synapse                        serve on a random local port and open the UI
+  synapse serve [--port N] [--no-open] [--claude-dir DIR] [--codex-dir DIR] [--pi-dir DIR]
+  synapse open [--no-open] <session.jsonl> open a specific Claude Code, Codex, or pi session
+  synapse map [--no-open] <repo>  open the repository citymap with no session
+  synapse build <repo> [-o out]  write citymap.json
+  synapse trace <session> [-o out] write trace.json
+  synapse analyze <session> [-o out] [--judge claude|codex] [--no-cache] [--no-rubric] evaluate a session with a local agent CLI`)
+}

package/cmd/synapse/main_test.go

@@ -0,0 +1,16 @@
+package main
+
+import "testing"
+
+func TestParseOutputArgsAllowsTrailingOutput(t *testing.T) {
+	positional, out, err := parseOutputArgs([]string{"repo", "-o", "citymap.json"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(positional) != 1 || positional[0] != "repo" {
+		t.Fatalf("positional = %#v", positional)
+	}
+	if out != "citymap.json" {
+		t.Fatalf("out = %q", out)
+	}
+}

package/go.mod

@@ -0,0 +1,7 @@
+module github.com/hybridlabor-api/bdb-synapse
+
+go 1.25
+
+require github.com/santhosh-tekuri/jsonschema/v6 v6.0.2
+
+require golang.org/x/text v0.14.0 // indirect

package/go.sum

@@ -0,0 +1,6 @@
+github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
+github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/santhosh-tekuri/jsonschema/v6 v6.0.2 h1:KRzFb2m7YtdldCEkzs6KqmJw4nqEVZGK7IN2kJkjTuQ=
+github.com/santhosh-tekuri/jsonschema/v6 v6.0.2/go.mod h1:JXeL+ps8p7/KNMjDQk3TCwPpBy0wYklyWTfbkIzdIFU=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=