refactor: move out main

Author: AsterDY

.gitignore

@@ -74,3 +74,4 @@ src/lang/testdata
 *.json
 
 tools
+abcoder

go.go

@@ -29,11 +29,11 @@ import (
 )
 
 type CollectOption struct {
+	Language           lsp.Language
 	LoadExternalSymbol bool
 	NeedStdSymbol      bool
 	NoNeedComment      bool
 	NeedTest           bool
-	Language           lsp.Language
 	Excludes           []string
 }
 

lang/collect/collect.go

@@ -50,7 +50,7 @@ func NewLSPClient(repo string, openfile string, wait time.Duration, opts ClientO
 		return nil, err
 	}
 
-	cli, err := initLSPClient(context.Background(), svr, lsp.DocumentURI(NewURI(repo)), opts.Verbose)
+	cli, err := initLSPClient(context.Background(), svr, NewURI(repo), opts.Verbose)
 	if err != nil {
 		return nil, err
 	}
@@ -110,7 +110,7 @@ type initializeResult struct {
 	Capabilities interface{} `json:"capabilities,omitempty"`
 }
 
-func initLSPClient(ctx context.Context, svr io.ReadWriteCloser, dir lsp.DocumentURI, verbose bool) (*LSPClient, error) {
+func initLSPClient(ctx context.Context, svr io.ReadWriteCloser, dir DocumentURI, verbose bool) (*LSPClient, error) {
 	h := newLSPHandler()
 	stream := jsonrpc2.NewBufferedStream(svr, jsonrpc2.VSCodeObjectCodec{})
 	conn := jsonrpc2.NewConn(ctx, stream, h)
@@ -131,7 +131,7 @@ func initLSPClient(ctx context.Context, svr io.ReadWriteCloser, dir lsp.Document
 
 	initParams := initializeParams{
 		ProcessID:    os.Getpid(),
-		RootURI:      dir,
+		RootURI:      lsp.DocumentURI(dir),
 		Capabilities: cs,
 		Trace:        lsp.Trace(trace),
 		ClientInfo:   lsp.ClientInfo{Name: "vscode"},

lang/lsp/client.go

@@ -14,15 +14,31 @@
 
 package lsp
 
-import "github.com/cloudwego/abcoder/lang/uniast"
+import (
+	"strings"
+
+	"github.com/cloudwego/abcoder/lang/uniast"
+)
 
 type Language string
 
 const (
-	Rust   Language = "rust"
-	Golang Language = "golang"
+	Rust    Language = "rust"
+	Golang  Language = "golang"
+	Unknown Language = ""
 )
 
+func NewLanguage(l string) Language {
+	switch strings.ToLower(l) {
+	case "rust":
+		return Rust
+	case "go", "golang":
+		return Golang
+	default:
+		return Unknown
+	}
+}
+
 func (l Language) String() string {
 	switch l {
 	case Rust:

lang/lsp/spec.go

@@ -0,0 +1,188 @@
+/**
+ * Copyright 2025 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lang
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"time"
+
+	"github.com/cloudwego/abcoder/lang/collect"
+	"github.com/cloudwego/abcoder/lang/golang/parser"
+	"github.com/cloudwego/abcoder/lang/log"
+	"github.com/cloudwego/abcoder/lang/lsp"
+	"github.com/cloudwego/abcoder/lang/rust"
+	"github.com/cloudwego/abcoder/lang/uniast"
+)
+
+type ParseOptions struct {
+	LSP     string
+	Verbose bool
+	collect.CollectOption
+}
+
+func Parse(ctx context.Context, uri string, args ParseOptions) ([]byte, error) {
+	if !filepath.IsAbs(uri) {
+		uri, _ = filepath.Abs(uri)
+	}
+	l, lspPath := checkLSP(args.Language, args.LSP)
+	openfile, opentime, err := checkRepoPath(uri, l)
+	if err != nil {
+		return nil, err
+	}
+
+	var client *lsp.LSPClient
+	if lspPath != "" {
+		// Initialize the LSP client
+		log.Info("start initialize LSP server %s...\n", lspPath)
+		var err error
+		client, err = lsp.NewLSPClient(uri, openfile, opentime, lsp.ClientOptions{
+			Server:   lspPath,
+			Language: l,
+			Verbose:  args.Verbose,
+		})
+		if err != nil {
+			log.Error("failed to initialize LSP server: %v\n", err)
+			return nil, err
+		}
+		log.Info("end initialize LSP server")
+	}
+
+	repo, err := collectSymbol(ctx, client, uri, args.CollectOption)
+	if err != nil {
+		log.Error("Failed to collect symbols: %v\n", err)
+		return nil, err
+	}
+	log.Info("all symbols collected, start writing to stdout...\n")
+	out, err := json.Marshal(repo)
+	if err != nil {
+		log.Error("Failed to marshal repository: %v\n", err)
+		return nil, err
+	}
+	return out, nil
+}
+
+func checkRepoPath(repoPath string, language lsp.Language) (openfile string, wait time.Duration, err error) {
+	if _, err := os.Stat(repoPath); os.IsNotExist(err) {
+		return "", 0, fmt.Errorf("repository not found: %s", repoPath)
+	}
+	switch language {
+	case lsp.Rust:
+		// NOTICE: open the Cargo.toml file is required for Rust projects
+		openfile, wait = rust.CheckRepo(repoPath)
+	default:
+		openfile = ""
+		wait = 0
+	}
+
+	log.Info("open file '%s' and wait for %d seconds for initialize workspace\n", openfile, wait/time.Second)
+	return
+}
+
+func checkVerbose(verbose bool, debug bool) {
+	if debug {
+
+	} else if verbose {
+		log.SetLogLevel(log.InfoLevel)
+	} else {
+		log.SetLogLevel(log.ErrorLevel)
+	}
+}
+
+func checkLSP(language lsp.Language, lspPath string) (l lsp.Language, s string) {
+	switch language {
+	case lsp.Rust:
+		l, s = rust.GetDefaultLSP()
+	case lsp.Golang:
+		l = lsp.Golang
+		s = ""
+		if _, err := exec.LookPath("go"); err != nil {
+			if _, err := os.Stat(lspPath); os.IsNotExist(err) {
+				log.Error("Go compiler not found, please make it excutable!\n", lspPath)
+				os.Exit(1)
+			}
+		}
+		return
+	default:
+		log.Error("Unsupported language: %s\n", language)
+		os.Exit(1)
+	}
+	// check if lsp excutable
+	if lspPath != "" {
+		if _, err := exec.LookPath(lspPath); err != nil {
+			if _, err := os.Stat(lspPath); os.IsNotExist(err) {
+				log.Error("Language server %s not found, please make it excutable!\n", lspPath)
+				os.Exit(1)
+			}
+		}
+		s = lspPath
+	}
+
+	return
+}
+
+func collectSymbol(ctx context.Context, cli *lsp.LSPClient, repoPath string, opts collect.CollectOption) (repo *uniast.Repository, err error) {
+	if opts.Language == lsp.Golang {
+		repo, err = callGoParser(ctx, repoPath, opts)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		collector := collect.NewCollector(repoPath, cli)
+		collector.CollectOption = opts
+		log.Info("start collecting symbols...\n")
+		err = collector.Collect(ctx)
+		if err != nil {
+			return nil, err
+		}
+		log.Info("all symbols collected.\n")
+		log.Info("start exporting symbols...\n")
+		repo, err = collector.Export(ctx)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if err := repo.BuildGraph(); err != nil {
+		return nil, err
+	}
+	return repo, nil
+}
+
+func callGoParser(ctx context.Context, repoPath string, opts collect.CollectOption) (*uniast.Repository, error) {
+	goopts := parser.Options{}
+	if opts.LoadExternalSymbol {
+		goopts.ReferCodeDepth = 1
+	}
+	if !opts.NoNeedComment {
+		goopts.CollectComment = true
+	}
+	if opts.NeedTest {
+		goopts.NeedTest = true
+	}
+	goopts.Excludes = opts.Excludes
+	p := parser.NewParser(repoPath, repoPath, goopts)
+	repo, err := p.ParseRepo()
+	if err != nil {
+		return nil, err
+	}
+	return &repo, nil
+}