goscript 0.0.84 → 0.1.0

package/README.md

@@ -89,6 +89,11 @@ npm install -g goscript
 goscript compile --package . --output ./dist
 ```
 
+GoScript v2 compiles Go packages from inside a Go module. Direct single-file
+inputs such as `main.go` and browser/WASM source-string compilation are not
+supported yet; those paths return structured diagnostics before output is
+written.
+
 ## 📦 Using Generated Code in Your Project
 
 After compiling your Go code to TypeScript, you'll need to set up your project appropriately.
@@ -125,6 +130,11 @@ Create or update your `tsconfig.json` with these settings:
 
 You should be able to use any TypeScript bundler to compile the generated TypeScript.
 
+For a generated `package main`, GoScript emits a main-script guard so the
+generated module can be executed directly by a TypeScript runtime or bundler
+that resolves `@goscript/*` imports. The `example/simple` package shows the
+supported compile-and-run workflow.
+
 ## 🛠️ Integration & Usage
 
 ### Command Line
@@ -135,8 +145,10 @@ goscript compile --package ./my-go-code --output ./dist
 
 **Options:**
 
-- `--package <path>` - Go package to compile (default: ".")
+- `--package <path>` - Go package pattern to compile
 - `--output <dir>` - Output directory for TypeScript files
+- `--dir <dir>` - Working directory for module/package loading
+- `--build-flags <flag>` - Go package loader build flag, repeatable
 
 ### Programmatic API
 

package/cmd/goscript/cmd_compile.go

@@ -10,83 +10,84 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-var (
-	cliCompiler           *compiler.Compiler
-	cliCompilerConfig     compiler.Config
-	cliCompilerPkg        cli.StringSlice
-	cliCompilerBuildFlags cli.StringSlice
-)
+func compileCommands() []*cli.Command {
+	return []*cli.Command{newCompileCommand()}
+}
 
-// CompileCommands are commands related to compiling code.
-var CompileCommands = []*cli.Command{{
-	Name:     "compile",
-	Category: "compile",
-	Usage:    "compile a Go package to TypeScript",
-	Action:   compilePackage,
-	Before: func(c *cli.Context) (err error) {
-		logger := logrus.New()
-		logger.SetLevel(logrus.DebugLevel)
-		le := logrus.NewEntry(logger)
-		cliCompiler, err = compiler.NewCompiler(&cliCompilerConfig, le, nil)
-		return
-	},
-	Flags: []cli.Flag{
-		&cli.StringSliceFlag{
-			Name:        "package",
-			Usage:       "the package(s) to compile",
-			Aliases:     []string{"p", "packages"},
-			EnvVars:     []string{"GOSCRIPT_PACKAGES"},
-			Destination: &cliCompilerPkg,
-		},
-		&cli.StringFlag{
-			Name:        "output",
-			Usage:       "the output typescript path to use",
-			Destination: &cliCompilerConfig.OutputPath,
-			Value:       "./output",
-			EnvVars:     []string{"GOSCRIPT_OUTPUT"},
-		},
-		&cli.StringFlag{
-			Name:        "dir",
-			Usage:       "the working directory to use for the compiler (default: current directory)",
-			Destination: &cliCompilerConfig.Dir,
-			Value:       "",
-			EnvVars:     []string{"GOSCRIPT_DIR"},
-		},
-		&cli.StringSliceFlag{
-			Name:        "build-flags",
-			Aliases:     []string{"b", "buildflags", "build-flag", "buildflag"},
-			Usage:       "Go build flags (tags) to use during analysis",
-			Destination: &cliCompilerBuildFlags,
-			EnvVars:     []string{"GOSCRIPT_BUILD_FLAGS"},
-		},
-		&cli.BoolFlag{
-			Name:        "disable-emit-builtin",
-			Usage:       "disable emitting built-in packages that have handwritten equivalents",
-			Destination: &cliCompilerConfig.DisableEmitBuiltin,
-			Value:       false,
-			EnvVars:     []string{"GOSCRIPT_DISABLE_EMIT_BUILTIN"},
+func newCompileCommand() *cli.Command {
+	var config compiler.Config
+	var packages cli.StringSlice
+	var buildFlags cli.StringSlice
+
+	return &cli.Command{
+		Name:     "compile",
+		Category: "compile",
+		Usage:    "compile a Go package to TypeScript",
+		Action: func(c *cli.Context) error {
+			config.BuildFlags = slices.Clone(buildFlags.Value())
+			return compilePackage(c.Context, &config, packages.Value())
 		},
-		&cli.BoolFlag{
-			Name:        "all-dependencies",
-			Usage:       "compile all dependencies of the requested packages",
-			Aliases:     []string{"all-deps", "deps"},
-			Destination: &cliCompilerConfig.AllDependencies,
-			Value:       false,
-			EnvVars:     []string{"GOSCRIPT_ALL_DEPENDENCIES"},
+		Flags: []cli.Flag{
+			&cli.StringSliceFlag{
+				Name:        "package",
+				Usage:       "the package(s) to compile",
+				Aliases:     []string{"p", "packages"},
+				EnvVars:     []string{"GOSCRIPT_PACKAGES"},
+				Destination: &packages,
+			},
+			&cli.StringFlag{
+				Name:        "output",
+				Usage:       "the output typescript path to use",
+				Destination: &config.OutputPath,
+				Value:       "./output",
+				EnvVars:     []string{"GOSCRIPT_OUTPUT"},
+			},
+			&cli.StringFlag{
+				Name:        "dir",
+				Usage:       "the working directory to use for the compiler (default: current directory)",
+				Destination: &config.Dir,
+				Value:       "",
+				EnvVars:     []string{"GOSCRIPT_DIR"},
+			},
+			&cli.StringSliceFlag{
+				Name:        "build-flags",
+				Aliases:     []string{"b", "buildflags", "build-flag", "buildflag"},
+				Usage:       "Go build flags (tags) to use during analysis",
+				Destination: &buildFlags,
+				EnvVars:     []string{"GOSCRIPT_BUILD_FLAGS"},
+			},
+			&cli.BoolFlag{
+				Name:        "disable-emit-builtin",
+				Usage:       "disable emitting built-in packages that have handwritten equivalents",
+				Destination: &config.DisableEmitBuiltin,
+				Value:       false,
+				EnvVars:     []string{"GOSCRIPT_DISABLE_EMIT_BUILTIN"},
+			},
+			&cli.BoolFlag{
+				Name:        "all-dependencies",
+				Usage:       "compile all dependencies of the requested packages",
+				Aliases:     []string{"all-deps", "deps"},
+				Destination: &config.AllDependencies,
+				Value:       false,
+				EnvVars:     []string{"GOSCRIPT_ALL_DEPENDENCIES"},
+			},
 		},
-	},
-}}
+	}
+}
 
 // compilePackage tries to compile the package.
-func compilePackage(c *cli.Context) error {
-	pkgs := cliCompilerPkg.Value()
+func compilePackage(ctx context.Context, config *compiler.Config, pkgs []string) error {
 	if len(pkgs) == 0 {
 		return errors.New("package(s) must be specified")
 	}
 
-	// build flags
-	cliCompilerConfig.BuildFlags = slices.Clone(cliCompilerBuildFlags.Value())
-
-	_, err := cliCompiler.CompilePackages(context.Background(), pkgs...)
+	logger := logrus.New()
+	logger.SetLevel(logrus.DebugLevel)
+	le := logrus.NewEntry(logger)
+	comp, err := compiler.NewCompiler(config, le, nil)
+	if err != nil {
+		return err
+	}
+	_, err = comp.CompilePackages(ctx, pkgs...)
 	return err
 }

package/cmd/goscript/cmd_compile_test.go

@@ -0,0 +1,79 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCompileCommandForwardsBuildFlags(t *testing.T) {
+	dir := t.TempDir()
+	outputDir := filepath.Join(dir, "output")
+	writeFile(t, filepath.Join(dir, "go.mod"), "module example.test/cli\n\ngo 1.25.3\n")
+	writeFile(t, filepath.Join(dir, "default.go"), strings.Join([]string{
+		"//go:build !customtag",
+		"",
+		"package main",
+		`const selected = "default"`,
+		"",
+	}, "\n"))
+	writeFile(t, filepath.Join(dir, "tagged.go"), strings.Join([]string{
+		"//go:build customtag",
+		"",
+		"package main",
+		`const selected = "custom"`,
+		"",
+	}, "\n"))
+	writeFile(t, filepath.Join(dir, "main.go"), strings.Join([]string{
+		"package main",
+		"func main() {",
+		"  println(selected)",
+		"}",
+		"",
+	}, "\n"))
+
+	app := newApp()
+	err := app.Run([]string{
+		"goscript",
+		"compile",
+		"--package",
+		".",
+		"--output",
+		outputDir,
+		"--dir",
+		dir,
+		"--build-flags",
+		"-tags=customtag",
+	})
+	if err != nil {
+		t.Fatalf("compile command failed: %v", err)
+	}
+
+	generatedPath := filepath.Join(outputDir, "@goscript", "example.test", "cli", "main.gs.ts")
+	generated, err := os.ReadFile(generatedPath)
+	if err != nil {
+		t.Fatalf("read generated file: %v", err)
+	}
+	if !strings.Contains(string(generated), `./tagged.gs.ts`) {
+		t.Fatalf("expected main output to import tagged source, got:\n%s", generated)
+	}
+	taggedPath := filepath.Join(outputDir, "@goscript", "example.test", "cli", "tagged.gs.ts")
+	tagged, err := os.ReadFile(taggedPath)
+	if err != nil {
+		t.Fatalf("read tagged generated file: %v", err)
+	}
+	if !strings.Contains(string(tagged), `"custom"`) {
+		t.Fatalf("expected tagged generated file to use tagged source, got:\n%s", tagged)
+	}
+	if strings.Contains(string(tagged), `"default"`) {
+		t.Fatalf("tagged generated file used source excluded by build tag:\n%s", tagged)
+	}
+}
+
+func writeFile(t *testing.T, path string, content string) {
+	t.Helper()
+	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+		t.Fatalf("write %s: %v", path, err)
+	}
+}

package/cmd/goscript/main.go

@@ -10,6 +10,14 @@ import (
 var version = "dev"
 
 func main() {
+	app := newApp()
+	if err := app.Run(os.Args); err != nil {
+		_, _ = os.Stderr.WriteString(err.Error() + "\n")
+		os.Exit(1)
+	}
+}
+
+func newApp() *cli.App {
 	app := cli.NewApp()
 	app.Version = version
 
@@ -18,10 +26,7 @@ func main() {
 	}
 
 	app.Usage = "GoScript compiles Go to Typescript."
-	app.Commands = append(app.Commands, CompileCommands...)
+	app.Commands = append(app.Commands, compileCommands()...)
 
-	if err := app.Run(os.Args); err != nil {
-		_, _ = os.Stderr.WriteString(err.Error() + "\n")
-		os.Exit(1)
-	}
+	return app
 }

package/compiler/compile-request.go

@@ -0,0 +1,218 @@
+package compiler
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// DependencyMode describes how much of the loaded package graph to keep.
+type DependencyMode string
+
+const (
+	// DependencyModeRequested keeps only requested package nodes.
+	DependencyModeRequested DependencyMode = "requested"
+	// DependencyModeAll keeps reachable dependency package nodes.
+	DependencyModeAll DependencyMode = "all"
+)
+
+// RuntimeEmissionMode describes how runtime packages should be handled.
+type RuntimeEmissionMode string
+
+const (
+	// RuntimeEmissionModeEmit emits required runtime packages with output.
+	RuntimeEmissionModeEmit RuntimeEmissionMode = "emit"
+	// RuntimeEmissionModeReference references runtime packages without emitting them.
+	RuntimeEmissionModeReference RuntimeEmissionMode = "reference"
+)
+
+// CompileRequest describes one compiler invocation after adapter normalization.
+type CompileRequest struct {
+	// Patterns are the Go package patterns requested by the caller.
+	Patterns []string
+	// Dir is the working directory for package loading.
+	Dir string
+	// OutputPath is the root where TypeScript output would be written.
+	OutputPath string
+	// BuildFlags are forwarded to the Go package loader.
+	BuildFlags []string
+	// DependencyMode controls whether dependencies are included in the graph.
+	DependencyMode DependencyMode
+	// RuntimeEmissionMode controls runtime package emission policy.
+	RuntimeEmissionMode RuntimeEmissionMode
+	// AllDependencies controls whether the package graph should include deps.
+	AllDependencies bool
+	// DisableEmitBuiltin controls whether runtime packages are emitted.
+	DisableEmitBuiltin bool
+}
+
+// CompileRequestOwner owns adapter input normalization and validation.
+type CompileRequestOwner struct{}
+
+// NewCompileRequestOwner creates a compile request owner.
+func NewCompileRequestOwner() *CompileRequestOwner {
+	return &CompileRequestOwner{}
+}
+
+// NewRequest builds a request from public compiler config and package patterns.
+func (o *CompileRequestOwner) NewRequest(conf Config, patterns []string) *CompileRequest {
+	dir := conf.Dir
+	if dir == "" {
+		dir = "."
+	}
+
+	dependencyMode := DependencyModeRequested
+	if conf.AllDependencies {
+		dependencyMode = DependencyModeAll
+	}
+	runtimeEmissionMode := RuntimeEmissionModeEmit
+	if conf.DisableEmitBuiltin {
+		runtimeEmissionMode = RuntimeEmissionModeReference
+	}
+
+	return &CompileRequest{
+		Patterns:            normalizePatterns(patterns),
+		Dir:                 strings.TrimSpace(dir),
+		OutputPath:          strings.TrimSpace(conf.OutputPath),
+		BuildFlags:          append([]string(nil), conf.BuildFlags...),
+		DependencyMode:      dependencyMode,
+		RuntimeEmissionMode: runtimeEmissionMode,
+		AllDependencies:     conf.AllDependencies,
+		DisableEmitBuiltin:  conf.DisableEmitBuiltin,
+	}
+}
+
+// Validate returns request diagnostics that must stop compilation before output.
+func (o *CompileRequestOwner) Validate(req *CompileRequest) []Diagnostic {
+	if req == nil {
+		return []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/request:nil",
+			Message:  "compile request is nil",
+		}}
+	}
+
+	var diagnostics []Diagnostic
+	if len(req.Patterns) == 0 {
+		diagnostics = append(diagnostics, Diagnostic{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/request:no-packages",
+			Message:  "at least one Go package pattern is required",
+			Detail:   "Use goscript compile --package . from inside a Go module.",
+		})
+	}
+	if strings.TrimSpace(req.OutputPath) == "" {
+		diagnostics = append(diagnostics, Diagnostic{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/request:no-output",
+			Message:  "output path root must be specified",
+		})
+	}
+	if strings.TrimSpace(req.Dir) == "" {
+		diagnostics = append(diagnostics, Diagnostic{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/request:no-working-dir",
+			Message:  "working directory must be specified",
+		})
+	} else {
+		info, err := os.Stat(req.Dir)
+		switch {
+		case err != nil:
+			diagnostics = append(diagnostics, Diagnostic{
+				Severity: DiagnosticSeverityError,
+				Code:     "goscript/request:working-dir",
+				Message:  "working directory is not readable",
+				Detail:   err.Error(),
+			})
+		case !info.IsDir():
+			diagnostics = append(diagnostics, Diagnostic{
+				Severity: DiagnosticSeverityError,
+				Code:     "goscript/request:working-dir",
+				Message:  "working directory must be a directory",
+			})
+		case !hasGoMod(req.Dir):
+			diagnostics = append(diagnostics, Diagnostic{
+				Severity: DiagnosticSeverityError,
+				Code:     "goscript/request:no-module",
+				Message:  "working directory is not inside a Go module",
+				Detail:   "Run goscript from a directory containing go.mod, or pass --dir for a module directory.",
+			})
+		}
+	}
+	if req.DependencyMode != DependencyModeRequested && req.DependencyMode != DependencyModeAll {
+		diagnostics = append(diagnostics, Diagnostic{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/request:dependency-mode",
+			Message:  "dependency mode is invalid",
+		})
+	}
+	if req.RuntimeEmissionMode != RuntimeEmissionModeEmit &&
+		req.RuntimeEmissionMode != RuntimeEmissionModeReference {
+		diagnostics = append(diagnostics, Diagnostic{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/request:runtime-emission-mode",
+			Message:  "runtime emission mode is invalid",
+		})
+	}
+	for _, flag := range req.BuildFlags {
+		if strings.TrimSpace(flag) == "" {
+			diagnostics = append(diagnostics, Diagnostic{
+				Severity: DiagnosticSeverityError,
+				Code:     "goscript/request:empty-build-flag",
+				Message:  "build flags must not contain empty values",
+			})
+		}
+	}
+
+	for _, pattern := range req.Patterns {
+		trimmed := strings.TrimSpace(pattern)
+		if trimmed == "" {
+			diagnostics = append(diagnostics, Diagnostic{
+				Severity: DiagnosticSeverityError,
+				Code:     "goscript/request:empty-package",
+				Message:  "package pattern must not be empty",
+			})
+			continue
+		}
+		if strings.HasSuffix(filepath.Base(trimmed), ".go") {
+			diagnostics = append(diagnostics, Diagnostic{
+				Severity: DiagnosticSeverityError,
+				Code:     "goscript/request:single-file-unsupported",
+				Message:  "single-file compilation is not supported by the v2 compiler",
+				Detail:   "Use a package pattern such as . or ./path from inside a Go module.",
+			})
+		}
+	}
+
+	return diagnostics
+}
+
+func normalizePatterns(patterns []string) []string {
+	if len(patterns) == 0 {
+		return nil
+	}
+
+	normalized := make([]string, 0, len(patterns))
+	for _, pattern := range patterns {
+		normalized = append(normalized, strings.TrimSpace(pattern))
+	}
+	return normalized
+}
+
+func hasGoMod(dir string) bool {
+	abs, err := filepath.Abs(dir)
+	if err != nil {
+		return false
+	}
+
+	for {
+		if _, err := os.Stat(filepath.Join(abs, "go.mod")); err == nil {
+			return true
+		}
+		parent := filepath.Dir(abs)
+		if parent == abs {
+			return false
+		}
+		abs = parent
+	}
+}