cmd/demo/main.go

package main

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"os"
	"strings"
	"time"

	spine "pysolate-spine"
)

func main() {
	artifact := flag.String("wasm", "dist/spine.wasm", "real CPython Wasm artifact")
	source := flag.String("source", "examples/lookup.py", "Python source")
	input := flag.String("inputs", `{"item":"book","quantity":2}`, "JSON inputs")
	plm := flag.Bool("plm", false, "prepare allowed snapshot reads early")
	show := flag.Bool("show-transformed", false, "print the actual Guest AST rendering to stderr")
	prefix := flag.Bool("prefix", false, "demo append-only source delivery in line fragments")
	prepared := flag.Bool("prepared-copy", false, "clone clean initialized memory by full copy; not COW")
	flag.Parse()
	if err := run(*artifact, *source, *input, *plm, *show, *prefix, *prepared); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

func demoTools() map[string]spine.Tool {
	// Host owns this immutable snapshot. No tool is available unless registered.
	catalog := map[string]any{"book": 21, "pen": 3, "shipping": 5, "choose": "pen"}
	return map[string]spine.Tool{"lookup": func(ctx context.Context, args json.RawMessage) (any, error) {
		var a struct {
			Key string `json:"key"`
		}
		if err := json.Unmarshal(args, &a); err != nil {
			return nil, err
		}
		price, ok := catalog[a.Key]
		if !ok {
			return nil, fmt.Errorf("missing key: %s", a.Key)
		}
		return price, nil
	}}
}

func run(artifact, source, input string, plm, show, prefix, prepared bool) error {
	wasm, err := os.ReadFile(artifact)
	if err != nil {
		return err
	}
	code, err := os.ReadFile(source)
	if err != nil {
		return err
	}
	var inputs any
	if err := json.Unmarshal([]byte(input), &inputs); err != nil {
		return err
	}
	tools := demoTools()
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()
	newRunner := spine.New
	if prepared {
		newRunner = spine.NewPrepared
	}
	runner, err := newRunner(ctx, wasm, tools, "lookup")
	if err != nil {
		return err
	}
	defer runner.Close(context.Background())
	var out spine.Output
	if prefix {
		// File replay is a small demo producer, not an LLM provider integration.
		chunks := make(chan string)
		go func() {
			defer close(chunks)
			for _, part := range strings.SplitAfter(string(code), "\n") {
				select {
				case chunks <- part:
				case <-ctx.Done():
					return
				}
			}
		}()
		out, err = runner.RunPrefix(ctx, chunks, inputs)
	} else {
		execute := runner.Run
		if plm {
			execute = runner.RunPLM
		}
		out, err = execute(ctx, string(code), inputs)
	}
	if show {
		switch {
		case out.Transformed != "":
			fmt.Fprintln(os.Stderr, out.Transformed)
		case !plm && !prefix:
			fmt.Fprintln(os.Stderr, "PLM: disabled")
		case err != nil:
			fmt.Fprintln(os.Stderr, "PLM: no transformed source (execution failed)")
		default:
			fmt.Fprintln(os.Stderr, "PLM: unchanged (no eligible rewrite)")
		}
	}
	fmt.Print(out.Stdout)
	if err != nil {
		return err
	}
	fmt.Println(string(out.Value))
	return nil
}