283 lines
8.6 KiB
Go
283 lines
8.6 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"database/sql"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
_ "github.com/mattn/go-sqlite3"
|
|
|
|
"fn-registry/registry"
|
|
)
|
|
|
|
func cmdRun(args []string) {
|
|
if len(args) == 0 {
|
|
fmt.Fprintln(os.Stderr, "usage: fn run <id_or_name> [args...]")
|
|
os.Exit(1)
|
|
}
|
|
|
|
idOrName := args[0]
|
|
passArgs := args[1:]
|
|
|
|
registryRoot := root()
|
|
dbPath := filepath.Join(registryRoot, dbName)
|
|
|
|
db, err := registry.Open(dbPath)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "error: cannot open registry: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
defer db.Close()
|
|
|
|
fn, err := resolveFunction(db, idOrName)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "error: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if fn.FilePath == "" {
|
|
fmt.Fprintf(os.Stderr, "error: %s has no file_path in registry\n", fn.ID)
|
|
os.Exit(1)
|
|
}
|
|
|
|
absPath := filepath.Join(registryRoot, fn.FilePath)
|
|
if _, err := os.Stat(absPath); os.IsNotExist(err) {
|
|
fmt.Fprintf(os.Stderr, "error: file not found: %s\n", absPath)
|
|
os.Exit(1)
|
|
}
|
|
|
|
cmd, err := buildCommand(fn, db, registryRoot, absPath, passArgs)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "error: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// When fn run executes a scoped `go test -run`, mirror its output into a
|
|
// buffer so we can detect a "no tests to run" result — which go test reports
|
|
// with exit 0 and would otherwise be a silent false-green (e.g. the extracted
|
|
// unit_tests names drifted from the code). See issue 0167.
|
|
guardGoTest := fn.Lang == "go" && isGoTestRun(cmd)
|
|
var outBuf bytes.Buffer
|
|
if guardGoTest {
|
|
cmd.Stdout = io.MultiWriter(os.Stdout, &outBuf)
|
|
cmd.Stderr = io.MultiWriter(os.Stderr, &outBuf)
|
|
} else {
|
|
cmd.Stdout = os.Stdout
|
|
cmd.Stderr = os.Stderr
|
|
}
|
|
cmd.Stdin = os.Stdin
|
|
|
|
fmt.Fprintf(os.Stderr, "[fn run] %s (%s/%s) %s\n", fn.ID, fn.Lang, fn.Kind, strings.Join(passArgs, " "))
|
|
|
|
t0 := time.Now()
|
|
runErr := cmd.Run()
|
|
durationMs := time.Since(t0).Milliseconds()
|
|
|
|
// A scoped go test that matched zero tests is a false-green: treat as failure.
|
|
if guardGoTest && runErr == nil && strings.Contains(outBuf.String(), "no tests to run") {
|
|
fmt.Fprintf(os.Stderr, "\n[fn run] error: -run no encontro ningun test para %s — los nombres de test extraidos no existen en el codigo; corre 'fn index'\n", fn.ID)
|
|
logFnRunTelemetry(registryRoot, fn.ID, durationMs, false, "no_tests_run")
|
|
os.Exit(1)
|
|
}
|
|
|
|
exitCode := 0
|
|
errClass := ""
|
|
if runErr != nil {
|
|
if exitErr, ok := runErr.(*exec.ExitError); ok {
|
|
exitCode = exitErr.ExitCode()
|
|
errClass = fmt.Sprintf("exit_%d", exitCode)
|
|
} else {
|
|
exitCode = 1
|
|
errClass = "spawn_error"
|
|
}
|
|
}
|
|
logFnRunTelemetry(registryRoot, fn.ID, durationMs, exitCode == 0, errClass)
|
|
|
|
if runErr != nil {
|
|
if errClass == "spawn_error" {
|
|
fmt.Fprintf(os.Stderr, "error: %v\n", runErr)
|
|
}
|
|
os.Exit(exitCode)
|
|
}
|
|
}
|
|
|
|
// logFnRunTelemetry inserts a row into call_monitor.operations.db.calls if
|
|
// the database is present. No-op silently otherwise — never blocks the run.
|
|
func logFnRunTelemetry(registryRoot, functionID string, durationMs int64, success bool, errClass string) {
|
|
callDB := filepath.Join(registryRoot, "projects", "fn_monitoring", "apps", "call_monitor", "operations.db")
|
|
if _, err := os.Stat(callDB); err != nil {
|
|
return
|
|
}
|
|
conn, err := sql.Open("sqlite3", callDB+"?_journal_mode=WAL&_busy_timeout=100")
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer conn.Close()
|
|
sessionID := os.Getenv("CLAUDE_SESSION_ID")
|
|
successInt := 0
|
|
if success {
|
|
successInt = 1
|
|
}
|
|
_, _ = conn.Exec(
|
|
`INSERT INTO calls (session_id, function_id, tool_used, args_hash, duration_ms, success, error_class, error_snippet, ts)
|
|
VALUES (?, ?, 'fn_run_cli', '', ?, ?, ?, '', CAST(strftime('%s','now') AS INTEGER))`,
|
|
sessionID, functionID, durationMs, successInt, errClass,
|
|
)
|
|
}
|
|
|
|
func resolveFunction(db *registry.DB, idOrName string) (*registry.Function, error) {
|
|
fn, err := db.GetFunction(idOrName)
|
|
if err == nil {
|
|
return fn, nil
|
|
}
|
|
|
|
fns, err := db.GetFunctionsByName(idOrName)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("lookup failed: %w", err)
|
|
}
|
|
if len(fns) == 0 {
|
|
return nil, fmt.Errorf("function %q not found (tried as ID and name)", idOrName)
|
|
}
|
|
if len(fns) == 1 {
|
|
return &fns[0], nil
|
|
}
|
|
|
|
var b strings.Builder
|
|
fmt.Fprintf(&b, "ambiguous name %q — found %d matches:\n", idOrName, len(fns))
|
|
for _, f := range fns {
|
|
fmt.Fprintf(&b, " %s (%s/%s)\n", f.ID, f.Lang, f.Kind)
|
|
}
|
|
fmt.Fprintf(&b, "use the full ID to disambiguate")
|
|
return nil, fmt.Errorf("%s", b.String())
|
|
}
|
|
|
|
func buildCommand(fn *registry.Function, db *registry.DB, registryRoot, absPath string, args []string) (*exec.Cmd, error) {
|
|
switch fn.Lang {
|
|
case "go":
|
|
return buildGoCommand(fn, db, registryRoot, absPath, args)
|
|
case "py":
|
|
return buildPyRunnerCommand(fn, db, registryRoot, args)
|
|
case "bash":
|
|
return buildBashCommand(absPath, args)
|
|
case "ts":
|
|
return buildTsCommand(registryRoot, absPath, args)
|
|
case "cpp":
|
|
return buildCppCommand(fn, registryRoot, absPath, args)
|
|
default:
|
|
return nil, fmt.Errorf("unsupported lang %q for execution", fn.Lang)
|
|
}
|
|
}
|
|
|
|
func buildGoCommand(fn *registry.Function, db *registry.DB, registryRoot, absPath string, args []string) (*exec.Cmd, error) {
|
|
dir := filepath.Dir(absPath)
|
|
env := append(os.Environ(), "CGO_ENABLED=1")
|
|
|
|
// If directory has main.go → go run . (pipelines and standalone executables)
|
|
mainGo := filepath.Join(dir, "main.go")
|
|
if _, err := os.Stat(mainGo); err == nil {
|
|
cmdArgs := append([]string{"run", "."}, args...)
|
|
cmd := exec.Command("go", cmdArgs...)
|
|
cmd.Dir = dir
|
|
cmd.Env = env
|
|
return cmd, nil
|
|
}
|
|
|
|
// Library code with tests → go test, but scoped to THIS function's tests via
|
|
// -run, so a flaky test of a sibling function in the same package does not
|
|
// break `fn run`. Test names come from the indexer-extracted unit_tests table
|
|
// (parsed from the real .go, reliable), never the .md frontmatter (can drift).
|
|
// The cmdRun guard fails the run if -run matches zero tests, preventing a
|
|
// silent "no tests to run" false-green. See issue 0167.
|
|
if fn.Tested && fn.TestFilePath != "" {
|
|
testAbs := filepath.Join(registryRoot, fn.TestFilePath)
|
|
if _, err := os.Stat(testAbs); err == nil {
|
|
relPkg, _ := filepath.Rel(registryRoot, dir)
|
|
pkgPath := "./" + filepath.ToSlash(relPkg)
|
|
cmdArgs := []string{"test", "-v", "-count=1", "-tags", "fts5"}
|
|
if names := goTestNames(db, fn.ID); len(names) > 0 {
|
|
cmdArgs = append(cmdArgs, "-run", "^("+strings.Join(names, "|")+")$")
|
|
}
|
|
cmdArgs = append(cmdArgs, pkgPath)
|
|
cmdArgs = append(cmdArgs, args...)
|
|
cmd := exec.Command("go", cmdArgs...)
|
|
cmd.Dir = registryRoot
|
|
cmd.Env = env
|
|
return cmd, nil
|
|
}
|
|
}
|
|
|
|
// No tests: go vet (compilation check)
|
|
relPkg, _ := filepath.Rel(registryRoot, dir)
|
|
pkgPath := "./" + filepath.ToSlash(relPkg)
|
|
cmdArgs := []string{"vet", "-tags", "fts5", pkgPath}
|
|
cmd := exec.Command("go", cmdArgs...)
|
|
cmd.Dir = registryRoot
|
|
cmd.Env = env
|
|
fmt.Fprintf(os.Stderr, "[fn run] %s is library code without tests — running go vet\n", fn.ID)
|
|
return cmd, nil
|
|
}
|
|
|
|
// goTestNames returns the top-level Go test function names registered for fn in
|
|
// the indexer-extracted unit_tests table. These drive `go test -run` so that
|
|
// `fn run` only executes the function's own tests, isolating it from flaky tests
|
|
// of sibling functions in the same package. Returns nil if none are known (db is
|
|
// nil, lookup fails, or no tests extracted), in which case the caller falls back
|
|
// to running the whole package.
|
|
func goTestNames(db *registry.DB, functionID string) []string {
|
|
if db == nil {
|
|
return nil
|
|
}
|
|
uts, err := db.GetUnitTestsByFunction(functionID)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
var names []string
|
|
for _, ut := range uts {
|
|
if ut.Name != "" {
|
|
names = append(names, ut.Name)
|
|
}
|
|
}
|
|
return names
|
|
}
|
|
|
|
// isGoTestRun reports whether cmd is a `go test ... -run ...` invocation, used to
|
|
// enable the zero-tests-matched guard in cmdRun.
|
|
func isGoTestRun(cmd *exec.Cmd) bool {
|
|
var hasTest, hasRun bool
|
|
for _, a := range cmd.Args {
|
|
switch a {
|
|
case "test":
|
|
hasTest = true
|
|
case "-run":
|
|
hasRun = true
|
|
}
|
|
}
|
|
return hasTest && hasRun
|
|
}
|
|
|
|
|
|
func buildBashCommand(absPath string, args []string) (*exec.Cmd, error) {
|
|
cmdArgs := append([]string{absPath}, args...)
|
|
cmd := exec.Command("bash", cmdArgs...)
|
|
cmd.Dir = filepath.Dir(absPath)
|
|
return cmd, nil
|
|
}
|
|
|
|
func buildTsCommand(registryRoot, absPath string, args []string) (*exec.Cmd, error) {
|
|
tsxBin := filepath.Join(registryRoot, "frontend", "node_modules", ".bin", "tsx")
|
|
if _, err := os.Stat(tsxBin); os.IsNotExist(err) {
|
|
return nil, fmt.Errorf("tsx not found — run: cd frontend && pnpm add -D tsx")
|
|
}
|
|
|
|
cmdArgs := append([]string{absPath}, args...)
|
|
cmd := exec.Command(tsxBin, cmdArgs...)
|
|
cmd.Dir = filepath.Dir(absPath)
|
|
return cmd, nil
|
|
}
|