module-spec 0.0.0-stage → 0.2.0

package/lib/languages/go/read_project.go

@@ -0,0 +1,433 @@
+// Command read_project reads a Go project for module-spec with Go's own parser: import edges down to
+// the file that declares each name used, what the scan plan's scans see, test package clauses and what
+// each door package exports.
+//
+// It takes one JSON request on stdin and prints one JSON answer on stdout.
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/printer"
+	"go/token"
+	"os"
+	"path"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// plan is the kit's scan plan (lib/scans.js): the files each scan searches.
+type plan struct {
+	Wait          []string `json:"wait"`
+	IO            []string `json:"io"`
+	Env           []string `json:"env"`
+	Complexity    []string `json:"complexity"`
+	MaxComplexity int      `json:"maxComplexity"`
+}
+
+type request struct {
+	ProjectRoot string   `json:"projectRoot"`
+	Files       []string `json:"files"`
+	TestFiles   []string `json:"testFiles"`
+	DoorDirs    []string `json:"doorDirs"`
+	Plan        plan     `json:"plan"`
+}
+
+type edge struct {
+	From     string `json:"from"`
+	Line     int    `json:"line"`
+	To       string `json:"to,omitempty"`
+	External string `json:"external,omitempty"`
+	Std      bool   `json:"std,omitempty"`
+}
+
+type found struct {
+	Scan   string `json:"scan,omitempty"`
+	File   string `json:"file"`
+	Line   int    `json:"line"`
+	Detail string `json:"detail"`
+}
+
+type answer struct {
+	Edges     []edge              `json:"edges"`
+	Sightings []found             `json:"sightings"`
+	WhiteBox  []found             `json:"whiteBox"`
+	Exports   map[string][]string `json:"exports"`
+}
+
+// saw records each of seen as a sighting of scan.
+func (a *answer) saw(scan string, seen []found) {
+	for _, sighting := range seen {
+		sighting.Scan = scan
+		a.Sightings = append(a.Sightings, sighting)
+	}
+}
+
+// pkg is one directory's package: its name, the file that declares each top-level name, and its files.
+type pkg struct {
+	name     string
+	declared map[string]string
+	files    []string
+}
+
+type project struct {
+	root       string
+	modulePath string
+	fset       *token.FileSet
+	parsed     map[string]*ast.File
+	packages   map[string]*pkg
+}
+
+var ioBuiltins = map[string]bool{"print": true, "println": true}
+var envReads = map[string]bool{"Getenv": true, "LookupEnv": true, "Environ": true, "ExpandEnv": true}
+
+func main() {
+	var req request
+	if err := json.NewDecoder(os.Stdin).Decode(&req); err != nil {
+		fail("reading the request: %v", err)
+	}
+	p := &project{root: req.ProjectRoot, fset: token.NewFileSet(), parsed: map[string]*ast.File{}, packages: map[string]*pkg{}}
+	p.modulePath = readModulePath(filepath.Join(req.ProjectRoot, "go.mod"))
+	out := answer{
+		Edges:     p.edges(req.Files),
+		Sightings: []found{},
+		WhiteBox:  p.whiteBox(req.TestFiles),
+		Exports:   map[string][]string{},
+	}
+	out.saw("wait", p.scan(req.Plan.Wait, waits))
+	out.saw("io", p.scan(req.Plan.IO, usesIOBuiltin))
+	out.saw("env", p.envReads(req.Plan.Env))
+	out.saw("complexity", p.complexity(req.Plan.Complexity, req.Plan.MaxComplexity))
+	for _, dir := range req.DoorDirs {
+		out.Exports[dir] = p.exports(dir)
+	}
+	if err := json.NewEncoder(os.Stdout).Encode(out); err != nil {
+		fail("writing the answer: %v", err)
+	}
+}
+
+func fail(format string, args ...any) {
+	fmt.Fprintf(os.Stderr, format+"\n", args...)
+	os.Exit(1)
+}
+
+func readModulePath(goMod string) string {
+	file, err := os.Open(goMod)
+	if err != nil {
+		fail("a Go project needs go.mod at its root: %v", err)
+	}
+	defer file.Close()
+	lines := bufio.NewScanner(file)
+	for lines.Scan() {
+		if fields := strings.Fields(lines.Text()); len(fields) == 2 && fields[0] == "module" {
+			return strings.Trim(fields[1], `"`)
+		}
+	}
+	fail("go.mod names no module")
+	return ""
+}
+
+func (p *project) parse(file string) *ast.File {
+	if parsed, ok := p.parsed[file]; ok {
+		return parsed
+	}
+	parsed, err := parser.ParseFile(p.fset, filepath.Join(p.root, file), nil, parser.SkipObjectResolution)
+	if err != nil {
+		fail("parsing %s: %v", file, err)
+	}
+	p.parsed[file] = parsed
+	return parsed
+}
+
+func (p *project) line(node ast.Node) int {
+	return p.fset.Position(node.Pos()).Line
+}
+
+// pkgAt reads the package in a project directory, test files left out.
+func (p *project) pkgAt(dir string) *pkg {
+	if known, ok := p.packages[dir]; ok {
+		return known
+	}
+	found := &pkg{declared: map[string]string{}}
+	entries, _ := os.ReadDir(filepath.Join(p.root, dir))
+	for _, entry := range entries {
+		name := entry.Name()
+		if entry.IsDir() || !strings.HasSuffix(name, ".go") || strings.HasSuffix(name, "_test.go") {
+			continue
+		}
+		file := path.Join(dir, name)
+		parsed := p.parse(file)
+		found.name = parsed.Name.Name
+		found.files = append(found.files, file)
+		for _, name := range topLevelNames(parsed) {
+			if _, taken := found.declared[name]; !taken {
+				found.declared[name] = file
+			}
+		}
+	}
+	sort.Strings(found.files)
+	p.packages[dir] = found
+	return found
+}
+
+func topLevelNames(file *ast.File) []string {
+	var names []string
+	for _, decl := range file.Decls {
+		switch decl := decl.(type) {
+		case *ast.FuncDecl:
+			if decl.Recv == nil {
+				names = append(names, decl.Name.Name)
+			}
+		case *ast.GenDecl:
+			for _, spec := range decl.Specs {
+				switch spec := spec.(type) {
+				case *ast.TypeSpec:
+					names = append(names, spec.Name.Name)
+				case *ast.ValueSpec:
+					for _, name := range spec.Names {
+						names = append(names, name.Name)
+					}
+				}
+			}
+		}
+	}
+	return names
+}
+
+// edges lists each file's imports. An import of a project package becomes an edge to each file that
+// declares a name the importer uses, so a check can tell a port from the adapter beside it.
+func (p *project) edges(files []string) []edge {
+	edges := []edge{}
+	for _, file := range files {
+		parsed := p.parse(file)
+		for _, imported := range parsed.Imports {
+			importPath := strings.Trim(imported.Path.Value, `"`)
+			line := p.line(imported)
+			if importPath != p.modulePath && !strings.HasPrefix(importPath, p.modulePath+"/") {
+				// The go command reserves import paths whose first element has no dot for the standard library.
+				std := !strings.Contains(strings.SplitN(importPath, "/", 2)[0], ".")
+				edges = append(edges, edge{From: file, Line: line, External: importPath, Std: std})
+				continue
+			}
+			dir := strings.TrimPrefix(strings.TrimPrefix(importPath, p.modulePath), "/")
+			if dir == "" {
+				dir = "."
+			}
+			target := p.pkgAt(dir)
+			alias := target.name
+			if imported.Name != nil {
+				alias = imported.Name.Name
+			}
+			for _, to := range filesUsed(parsed, alias, target) {
+				edges = append(edges, edge{From: file, Line: line, To: to})
+			}
+		}
+	}
+	return edges
+}
+
+func filesUsed(file *ast.File, alias string, target *pkg) []string {
+	used := map[string]bool{}
+	ast.Inspect(file, func(node ast.Node) bool {
+		if selector, ok := node.(*ast.SelectorExpr); ok {
+			if ident, ok := selector.X.(*ast.Ident); ok && ident.Name == alias {
+				if declaring, ok := target.declared[selector.Sel.Name]; ok {
+					used[declaring] = true
+				}
+			}
+		}
+		return true
+	})
+	if len(used) == 0 && len(target.files) > 0 {
+		used[target.files[0]] = true
+	}
+	files := make([]string, 0, len(used))
+	for file := range used {
+		files = append(files, file)
+	}
+	sort.Strings(files)
+	return files
+}
+
+func (p *project) scan(files []string, match func(ast.Node) string) []found {
+	results := []found{}
+	for _, file := range files {
+		ast.Inspect(p.parse(file), func(node ast.Node) bool {
+			if node != nil {
+				if detail := match(node); detail != "" {
+					results = append(results, found{File: file, Line: p.line(node), Detail: detail})
+				}
+			}
+			return true
+		})
+	}
+	return results
+}
+
+// waits reports Go's ways to wait: a goroutine, a channel send or receive, a select.
+func waits(node ast.Node) string {
+	switch node := node.(type) {
+	case *ast.GoStmt:
+		return "go"
+	case *ast.SendStmt:
+		return "send"
+	case *ast.SelectStmt:
+		return "select"
+	case *ast.UnaryExpr:
+		if node.Op == token.ARROW {
+			return "receive"
+		}
+	}
+	return ""
+}
+
+func usesIOBuiltin(node ast.Node) string {
+	if call, ok := node.(*ast.CallExpr); ok {
+		if ident, ok := call.Fun.(*ast.Ident); ok && ioBuiltins[ident.Name] {
+			return "uses " + ident.Name
+		}
+	}
+	return ""
+}
+
+func (p *project) envReads(files []string) []found {
+	results := []found{}
+	for _, file := range files {
+		parsed := p.parse(file)
+		alias := ""
+		for _, imported := range parsed.Imports {
+			if strings.Trim(imported.Path.Value, `"`) == "os" {
+				alias = "os"
+				if imported.Name != nil {
+					alias = imported.Name.Name
+				}
+			}
+		}
+		if alias == "" {
+			continue
+		}
+		ast.Inspect(parsed, func(node ast.Node) bool {
+			if selector, ok := node.(*ast.SelectorExpr); ok {
+				if ident, ok := selector.X.(*ast.Ident); ok && ident.Name == alias && envReads[selector.Sel.Name] {
+					results = append(results, found{File: file, Line: p.line(node), Detail: "reads os." + selector.Sel.Name})
+				}
+			}
+			return true
+		})
+	}
+	return results
+}
+
+// whiteBox reports test files compiled into the package they test, which lets them see its inside.
+func (p *project) whiteBox(files []string) []found {
+	results := []found{}
+	for _, file := range files {
+		name := p.parse(file).Name
+		if !strings.HasSuffix(name.Name, "_test") {
+			detail := fmt.Sprintf("is in package %s, so it sees inside the module: use package %s_test and import the door", name.Name, name.Name)
+			results = append(results, found{File: file, Line: p.line(name), Detail: detail})
+		}
+	}
+	return results
+}
+
+// complexity counts each function's paths the way cyclomatic complexity does: one, plus each branch.
+func (p *project) complexity(files []string, max int) []found {
+	results := []found{}
+	for _, file := range files {
+		for _, decl := range p.parse(file).Decls {
+			function, ok := decl.(*ast.FuncDecl)
+			if !ok || function.Body == nil {
+				continue
+			}
+			paths := 1
+			ast.Inspect(function.Body, func(node ast.Node) bool {
+				switch node := node.(type) {
+				case *ast.IfStmt, *ast.ForStmt, *ast.RangeStmt:
+					paths++
+				case *ast.CaseClause:
+					if node.List != nil {
+						paths++
+					}
+				case *ast.CommClause:
+					if node.Comm != nil {
+						paths++
+					}
+				case *ast.BinaryExpr:
+					if node.Op == token.LAND || node.Op == token.LOR {
+						paths++
+					}
+				}
+				return true
+			})
+			if paths > max {
+				detail := fmt.Sprintf("function %s has a complexity of %d, above %d", function.Name.Name, paths, max)
+				results = append(results, found{File: file, Line: p.line(function), Detail: detail})
+			}
+		}
+	}
+	return results
+}
+
+// exports lists what a door package exports, one line each: functions and methods with their
+// signatures, types with their definitions, constants and variables.
+func (p *project) exports(dir string) []string {
+	lines := []string{}
+	for _, file := range p.pkgAt(dir).files {
+		for _, decl := range p.parse(file).Decls {
+			switch decl := decl.(type) {
+			case *ast.FuncDecl:
+				if decl.Name.IsExported() && (decl.Recv == nil || receiverExported(decl.Recv)) {
+					lines = append(lines, p.print(&ast.FuncDecl{Recv: decl.Recv, Name: decl.Name, Type: decl.Type}))
+				}
+			case *ast.GenDecl:
+				for _, spec := range decl.Specs {
+					switch spec := spec.(type) {
+					case *ast.TypeSpec:
+						if spec.Name.IsExported() {
+							lines = append(lines, "type "+p.print(spec))
+						}
+					case *ast.ValueSpec:
+						for _, name := range spec.Names {
+							if !name.IsExported() {
+								continue
+							}
+							line := decl.Tok.String() + " " + name.Name
+							if spec.Type != nil {
+								line += " " + p.print(spec.Type)
+							}
+							lines = append(lines, line)
+						}
+					}
+				}
+			}
+		}
+	}
+	sort.Strings(lines)
+	return lines
+}
+
+func receiverExported(receiver *ast.FieldList) bool {
+	expr := receiver.List[0].Type
+	if star, ok := expr.(*ast.StarExpr); ok {
+		expr = star.X
+	}
+	if index, ok := expr.(*ast.IndexExpr); ok {
+		expr = index.X
+	}
+	ident, ok := expr.(*ast.Ident)
+	return ok && ident.IsExported()
+}
+
+func (p *project) print(node any) string {
+	var buffer bytes.Buffer
+	if err := printer.Fprint(&buffer, p.fset, node); err != nil {
+		fail("printing an export: %v", err)
+	}
+	return strings.Join(strings.Fields(buffer.String()), " ")
+}

package/lib/languages/go/scaffold.js

@@ -0,0 +1,28 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { toPosix } from "../../files.js";
+import { copyTemplates } from "../../templating.js";
+
+const TEMPLATES = path.join(path.dirname(fileURLToPath(import.meta.url)), "templates");
+
+/** The module's Go package name and import path, from go.mod at the project root. */
+function goValues(root, dir) {
+  const goMod = path.join(root, "go.mod");
+  if (!fs.existsSync(goMod)) throw new Error("a Go module needs go.mod at the project root: run go mod init");
+  const modulePath = /^module\s+"?([^\s"]+)"?/m.exec(fs.readFileSync(goMod, "utf8"))?.[1];
+  if (!modulePath) throw new Error("go.mod names no module");
+  return { pkg: path.basename(dir).toLowerCase().replace(/[^a-z0-9_]/g, ""), importPath: `${modulePath}/${toPosix(dir)}` };
+}
+
+export function newModule(root, dir, values) {
+  const written = [];
+  copyTemplates(root, path.join(TEMPLATES, "module"), dir, { ...values, ...goValues(root, dir) }, written);
+  return written;
+}
+
+export function newPort(root, dir, values) {
+  const written = [];
+  copyTemplates(root, path.join(TEMPLATES, "port"), dir, { ...values, ...goValues(root, dir) }, written);
+  return written;
+}

package/lib/languages/go/templates/module/internal/shell/create.go

@@ -0,0 +1,14 @@
+// Package shell loads what the core needs, calls it, and saves what it returns.
+package shell
+
+// Deps is what the app passes in.
+type Deps struct{}
+
+// {{Name}} is what the module does for its callers.
+type {{Name}} struct{}
+
+// New builds {{name}} from what the app passes in.
+func New(deps Deps) {{Name}} {
+	_ = deps
+	return {{Name}}{}
+}

package/lib/languages/go/templates/module/{{pkg}}.go

@@ -0,0 +1,15 @@
+// Package {{pkg}} owns {{owns}}. This file is its door: only what it exports is public.
+package {{pkg}}
+
+import "{{importPath}}/internal/shell"
+
+// Deps is what the app passes in.
+type Deps = shell.Deps
+
+// {{Name}} is what the module does for its callers.
+type {{Name}} = shell.{{Name}}
+
+// New builds {{name}} from what the app passes in.
+func New(deps Deps) {{Name}} {
+	return shell.New(deps)
+}

package/lib/languages/go/templates/module/{{pkg}}_test.go

@@ -0,0 +1,13 @@
+package {{pkg}}_test
+
+import (
+	"testing"
+
+	"{{importPath}}"
+)
+
+func TestNewBuilds{{Name}}FromItsDeps(t *testing.T) {
+	if got := {{pkg}}.New({{pkg}}.Deps{}); got != ({{pkg}}.{{Name}}{}) {
+		t.Fatalf("New() = %v", got)
+	}
+}

package/lib/languages/go/templates/port/internal/adapters/in_memory_{{portSnake}}.go

@@ -0,0 +1,10 @@
+package adapters
+
+import "{{importPath}}/internal/ports"
+
+type inMemory{{Port}} struct{}
+
+// NewInMemory{{Port}} is the fake every behaviour test passes in.
+func NewInMemory{{Port}}() ports.{{Port}} {
+	return inMemory{{Port}}{}
+}

package/lib/languages/go/templates/port/internal/ports/{{portSnake}}.go

@@ -0,0 +1,5 @@
+// Package ports holds the interfaces the core needs from the outside, named after the need.
+package ports
+
+// {{Port}} is one thing the core needs from the outside.
+type {{Port}} interface{}

package/lib/languages/go/templates/port/{{portSnake}}_contract_test.go

@@ -0,0 +1,20 @@
+package {{pkg}}_test
+
+import (
+	"testing"
+
+	"{{importPath}}/internal/adapters"
+	"{{importPath}}/internal/ports"
+)
+
+// {{portCamel}}Contract holds one test per promise {{Port}} makes. Every adapter runs this same
+// suite, so the fake cannot drift from the real one.
+func {{portCamel}}Contract(t *testing.T, make func() ports.{{Port}}) {
+	if make() == nil {
+		t.Fatal("make() returned no {{Port}}")
+	}
+}
+
+func Test{{Port}}ContractInMemory(t *testing.T) {
+	{{portCamel}}Contract(t, adapters.NewInMemory{{Port}})
+}

package/lib/languages/index.js

@@ -0,0 +1,66 @@
+import fs from "node:fs";
+import path from "node:path";
+import go from "./go/index.js";
+import python from "./python/index.js";
+import typescript from "./typescript/index.js";
+
+/**
+ * Everything the kit knows about one language. The rules never name a language: they ask this.
+ * A language is supported once its folder passes the conformance suite in __tests__/conformance.
+ *
+ * @typedef {object} Language
+ * @property {string} name            its key in module-spec.json and in messages: "typescript"
+ * @property {string[]} aliases       short names for `new-module --lang`: ["ts"]
+ * @property {string} door            the door as people name it, for messages: "index.ts"
+ * @property {(inner: string) => boolean} isDoor          whether a path inside a module is its door
+ * @property {string} partsDir        the folder that holds core/, shell/, ports/ and adapters/, or "" for the module root
+ * @property {(file: string) => boolean} isSource         whether a file is this language's source code
+ * @property {(segments: string[]) => boolean} isTest     whether a file, as path segments inside its module, is a test
+ * @property {(name: string) => boolean} isContractTest   whether a file name is a port's contract test
+ * @property {(file: string) => string | null} contractTestFor   the contract test's file name for a file in ports/, or null when it holds no port
+ * @property {{ io: string[], ui: string[] }} stdlib   the standard library modules that touch the outside, and those that draw
+ *   the user interface; an entry ending in "/" matches a scope. A third-party package is never named here: the project lists it
+ * @property {string[]} viewUi        the packages the view template draws with, which `new-module --view` lists under ui
+ * @property {object} configDefaults  this language's own keys in module-spec.json, under its name
+ * @property {(root: string) => boolean} detect           whether the project at root is written in this language
+ * @property {(input: { root: string, config: object, modules: object[], plan: import("../scans.js").ScanPlan }) => Promise<Reading>} analyze
+ * @property {(root: string, dir: string, values: object) => string[]} newModule   writes a module, returns the files written
+ * @property {(root: string, dir: string, values: object) => string[]} newPort     writes a port, returns the files written
+ * @property {((root: string, dir: string, values: object) => string[]) | undefined} newViewModule   writes a module with a view/, when the language has a template for one
+ * @property {(input: { root: string, config: object, module: object, files: string[], tests: string[] }) => Promise<Mutation>} mutate
+ *   mutation-tests `files` with only `tests`, by the language's own tool, without writing into the project
+ *
+ * @typedef {object} Reading       what a language's own tools read from its modules
+ * @property {object[]} edges      { from, line, to, typeOnly } for a project file, or { from, line, external, std } for a package.
+ *   typeOnly is true when every import of that file is erased before the code runs. std says whether the
+ *   language's toolchain counts the package as the standard library
+ * @property {import("../scans.js").Sighting[]} sightings   what the plan's scans saw; the kit names the rule
+ * @property {object[]} findings   violations only this language's tools can see: { id, file, line, detail }
+ * @property {Map<string, string[]>} api   each module's door exports, one line each, by module name
+ *
+ * @typedef {object} Mutation      what a mutation run found
+ * @property {number} killed        mutants some test failed for, timeouts included
+ * @property {{ file: string, line: number, detail: string }[]} survivors   mutants every test passed with, or no test reached
+ */
+
+/** @type {Language[]} Adding a language means adding its folder and one entry here. */
+export const LANGUAGES = [typescript, python, go];
+
+/** The language a name or alias names, such as "py". */
+export function languageNamed(name) {
+  const found = LANGUAGES.find((language) => language.name === name || language.aliases.includes(name));
+  if (!found) throw new Error(`unknown language ${name}: use one of ${LANGUAGES.flatMap((language) => language.aliases).join(", ")}`);
+  return found;
+}
+
+/** The language of the module folder `dir`, told by which door it has, or null. */
+export function languageOfDir(dir) {
+  if (!fs.existsSync(dir)) return null;
+  const names = fs.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name);
+  return LANGUAGES.find((language) => names.some((name) => language.isDoor(name))) ?? null;
+}
+
+/** Every door's name, for messages such as "add index.ts or __init__.py". */
+export function doorNames() {
+  return LANGUAGES.map((language) => language.door).join(" or ");
+}

package/lib/languages/python/environment.js

@@ -0,0 +1,15 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/** The project's own interpreter: module-spec.json python.executable, else .venv, else python3 on the PATH. */
+export function pythonOf(root, config) {
+  if (config.python.executable) return path.resolve(root, config.python.executable);
+  const venv = path.join(root, ".venv", "bin", "python");
+  return fs.existsSync(venv) ? venv : "python3";
+}
+
+/** A tool installed in the same environment as `python`, else the one on the PATH. */
+export function toolBeside(python, name) {
+  const beside = path.join(path.dirname(python), name);
+  return fs.existsSync(beside) ? beside : name;
+}

package/lib/languages/python/index.js

@@ -0,0 +1,35 @@
+import fs from "node:fs";
+import path from "node:path";
+import { mutate } from "./mutate.js";
+import { analyze } from "./read.js";
+import { newModule, newPort } from "./scaffold.js";
+
+const TEST = /^test_.*\.py$|_test\.py$/;
+const CONTRACT_TEST = /^test_.*_contract\.py$/;
+
+/** @type {import("../index.js").Language} */
+export default {
+  name: "python",
+  aliases: ["py"],
+  door: "__init__.py",
+  isDoor: (inner) => inner === "__init__.py",
+  partsDir: "",
+  isSource: (file) => file.endsWith(".py"),
+  isTest: (segments) => segments.includes("tests") || TEST.test(segments.at(-1)),
+  isContractTest: (name) => CONTRACT_TEST.test(name),
+  contractTestFor: (file) => (file === "__init__.py" ? null : `test_${file.replace(/\.py$/, "")}_contract.py`),
+  stdlib: {
+    io: [
+      "os", "pathlib", "socket", "subprocess", "sqlite3", "shutil", "http", "asyncio", "ssl", "smtplib",
+      "ftplib", "tempfile", "glob", "select", "selectors", "multiprocessing", "threading", "signal",
+    ],
+    ui: ["tkinter", "turtle", "curses"],
+  },
+  viewUi: [],
+  configDefaults: { executable: null },
+  detect: (root) => ["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt"].some((file) => fs.existsSync(path.join(root, file))),
+  analyze,
+  mutate,
+  newModule,
+  newPort,
+};