feat(cli): default entrypoints

apps/wing/package.json

@@ -41,6 +41,7 @@
     "commander": "^10.0.1",
     "compare-versions": "^5.0.3",
     "debug": "^4.3.4",
+    "glob": "^10.3.10",
     "nanoid": "^3.3.6",
     "open": "^8.4.2",
     "ora": "^5.4.1",

apps/wing/src/cli.ts

@@ -5,7 +5,6 @@ import { collectCommandAnalytics } from "./analytics/collect";
 import { optionallyDisplayDisclaimer } from "./analytics/disclaimer";
 import { exportAnalytics } from "./analytics/export";
 import { currentPackage } from "./util";
-
 export const PACKAGE_VERSION = currentPackage.version;
 let analyticsExportFile: Promise<string | undefined>;
 
@@ -133,7 +132,7 @@ async function main() {
   program
     .command("compile")
     .description("Compiles a Wing program")
-    .argument("<entrypoint>", "program .w entrypoint")
+    .argument("[entrypoint]", "program .w entrypoint")
     .addOption(
       new Option("-t, --target <target>", "Target platform")
         .choices(["tf-aws", "tf-azure", "tf-gcp", "sim", "awscdk"])
@@ -150,7 +149,7 @@ async function main() {
     .description(
       "Compiles a Wing program and runs all functions with the word 'test' or start with 'test:' in their resource identifiers"
     )
-    .argument("<entrypoint...>", "all entrypoints to test")
+    .argument("[entrypoint...]", "all files to test (globs are supported)")
     .addOption(
       new Option("-t, --target <target>", "Target platform")
         .choices(["tf-aws", "tf-azure", "tf-gcp", "sim", "awscdk"])

apps/wing/src/commands/compile.test.ts

@@ -1,4 +1,6 @@
-import { readdir, stat, writeFile } from "fs/promises";
+import { writeFileSync } from "fs";
+import { readdir, stat, writeFile, mkdtemp } from "fs/promises";
+import { tmpdir } from "os";
 import { join, resolve } from "path";
 import { Target } from "@winglang/compiler";
 import { describe, test, expect } from "vitest";
@@ -40,6 +42,37 @@ describe(
       expect(files).toEqual([".wing", "connections.json", "simulator.json", "tree.json"]);
     });
 
+    test("should be able to compile to default target sim", async () => {
+      const outDir = await compile(exampleFilePath, {
+        targetDir: `${await generateTmpDir()}/target`,
+      });
+
+      const stats = await stat(outDir);
+      expect(stats.isDirectory()).toBeTruthy();
+      const files = (await readdir(outDir)).sort();
+      expect(files.length).toBeGreaterThan(0);
+      expect(files).toEqual([".wing", "connections.json", "simulator.json", "tree.json"]);
+    });
+
+    test("should be able to compile the only entrypoint file in current directory", async () => {
+      const outDir = await mkdtemp(join(tmpdir(), "-wing-compile-test"));
+      const prevdir = process.cwd();
+
+      try {
+        process.chdir(outDir);
+        writeFileSync("main.w", "bring cloud;");
+        await compile();
+
+        const stats = await stat(outDir);
+        expect(stats.isDirectory()).toBeTruthy();
+        const files = (await readdir(outDir)).sort();
+        expect(files.length).toBeGreaterThan(0);
+        expect(files).toEqual(["main.w", "target"]);
+      } finally {
+        process.chdir(prevdir);
+      }
+    });
+
     test("should error if a nonexistent file is compiled", async () => {
       return expect(compile("non-existent-file.w", { target: Target.SIM })).rejects.toThrowError(
         /Source file cannot be found/

apps/wing/src/commands/compile.ts

@@ -5,6 +5,7 @@ import * as wingCompiler from "@winglang/compiler";
 import chalk from "chalk";
 import { CHARS_ASCII, emitDiagnostic, File, Label } from "codespan-wasm";
 import debug from "debug";
+import { glob } from "glob";
 
 // increase the stack trace limit to 50, useful for debugging Rust panics
 // (not setting the limit too high in case of infinite recursion)
@@ -17,19 +18,23 @@ const log = debug("wing:compile");
  * This is passed from Commander to the `compile` function.
  */
 export interface CompileOptions {
-  readonly target: wingCompiler.Target;
-  readonly plugins?: string[];
   readonly rootId?: string;
+  readonly plugins?: string[];
   /**
-   * Whether to run the compiler in `wing test` mode. This may create multiple
-   * copies of the application resources in order to run tests in parallel.
+   * The target to compile to
+   * @default wingCompiler.Target.SIM
    */
-  readonly testing?: boolean;
+  readonly target?: wingCompiler.Target;
   /**
    * The location to save the compilation output
    * @default "./target"
    */
   readonly targetDir?: string;
+  /**
+   * Whether to run the compiler in `wing test` mode. This may create multiple
+   * copies of the application resources in order to run tests in parallel.
+   */
+  readonly testing?: boolean;
 }
 
 /**
@@ -38,14 +43,22 @@ export interface CompileOptions {
  * @param options Compile options.
  * @returns the output directory
  */
-export async function compile(entrypoint: string, options: CompileOptions): Promise<string> {
+export async function compile(entrypoint?: string, options?: CompileOptions): Promise<string> {
+  if (!entrypoint) {
+    const wingFiles = await glob("{main,*.main}.w");
+    if (wingFiles.length !== 1) {
+      throw new Error("Please specify which file you want to compile");
+    }
+    entrypoint = wingFiles[0];
+  }
+
   const coloring = chalk.supportsColor ? chalk.supportsColor.hasBasic : false;
   try {
     return await wingCompiler.compile(entrypoint, {
       ...options,
       log,
       color: coloring,
-      targetDir: options.targetDir,
+      target: options?.target || wingCompiler.Target.SIM,
     });
   } catch (error) {
     if (error instanceof wingCompiler.CompileError) {

apps/wing/src/commands/run.test.ts

@@ -19,17 +19,17 @@ vi.mock("@wingconsole/app", () => {
   };
 });
 
-test("wing it runs the only .w file", async () => {
+test("wing it runs the only entrypoint file named main.w", async () => {
   const workdir = await mkdtemp(join(tmpdir(), "-wing-it-test"));
   const prevdir = process.cwd();
   try {
     process.chdir(workdir);
 
-    writeFileSync("foo.w", "bring cloud;");
+    writeFileSync("main.w", "bring cloud;");
 
     await run();
     expect(createConsoleApp).toBeCalledWith({
-      wingfile: resolve("foo.w"),
+      wingfile: resolve("main.w"),
       requestedPort: 3000,
       hostUtils: expect.anything(),
       requireAcceptTerms: false,
@@ -40,37 +40,65 @@ test("wing it runs the only .w file", async () => {
   }
 });
 
-test("wing it with no file throws error for a directory with more than 1 .w file", async () => {
+test("wing it runs the only entrypoint file ending with .main.w", async () => {
   const workdir = await mkdtemp(join(tmpdir(), "-wing-it-test"));
   const prevdir = process.cwd();
   try {
     process.chdir(workdir);
 
-    writeFileSync("foo.w", "bring cloud;");
-    writeFileSync("bar.w", "bring cloud;");
+    writeFileSync("foo.main.w", "bring cloud;");
+
+    await run();
+    expect(createConsoleApp).toBeCalledWith({
+      wingfile: resolve("foo.main.w"),
+      requestedPort: 3000,
+      hostUtils: expect.anything(),
+      requireAcceptTerms: false,
+    });
+    expect(open).toBeCalledWith("http://localhost:3000/");
+  } finally {
+    process.chdir(prevdir);
+  }
+});
+
+test("wing it doesn't run the only entrypoint file ending with .test.w", async () => {
+  const workdir = await mkdtemp(join(tmpdir(), "-wing-it-test"));
+  const prevdir = process.cwd();
+  try {
+    process.chdir(workdir);
+
+    writeFileSync("foo.test.w", "bring cloud;");
 
     await expect(run).rejects.toThrow("Please specify which file you want to run");
   } finally {
     process.chdir(prevdir);
   }
 });
 
-test("wing it with a file runs", async () => {
+test("wing it throws error for a directory with a non-entrypoint file", async () => {
   const workdir = await mkdtemp(join(tmpdir(), "-wing-it-test"));
   const prevdir = process.cwd();
   try {
     process.chdir(workdir);
 
     writeFileSync("foo.w", "bring cloud;");
 
-    await run("foo.w");
-    expect(createConsoleApp).toBeCalledWith({
-      wingfile: resolve("foo.w"),
-      requestedPort: 3000,
-      hostUtils: expect.anything(),
-      requireAcceptTerms: false,
-    });
-    expect(open).toBeCalledWith("http://localhost:3000/");
+    await expect(run).rejects.toThrow("Please specify which file you want to run");
+  } finally {
+    process.chdir(prevdir);
+  }
+});
+
+test("wing it throws error for a directory with more than one entrypoint file", async () => {
+  const workdir = await mkdtemp(join(tmpdir(), "-wing-it-test"));
+  const prevdir = process.cwd();
+  try {
+    process.chdir(workdir);
+
+    writeFileSync("main.w", "bring cloud;");
+    writeFileSync("foo.main.w", "bring cloud;");
+
+    await expect(run).rejects.toThrow("Please specify which file you want to run");
   } finally {
     process.chdir(prevdir);
   }
@@ -79,7 +107,7 @@ test("wing it with a file runs", async () => {
 test("wing it with a nested file runs", async () => {
   const workdir = await mkdtemp(join(tmpdir(), "-wing-it-test"));
   const subdir = join(workdir, "subdir");
-  const filePath = join(subdir, "foo.w");
+  const filePath = join(subdir, "foo.main.w");
   const prevdir = process.cwd();
   try {
     process.chdir(workdir);
@@ -106,9 +134,9 @@ test("wing it with an invalid file throws exception", async () => {
   try {
     process.chdir(workdir);
 
-    writeFileSync("foo.w", "bring cloud;");
+    writeFileSync("foo.main.w", "bring cloud;");
 
-    await expect(run("bar.w")).rejects.toThrow("bar.w doesn't exist");
+    await expect(run("bar.main.w")).rejects.toThrow("bar.main.w doesn't exist");
   } finally {
     process.chdir(prevdir);
   }
@@ -120,11 +148,11 @@ test("wing it with a custom port runs", async () => {
   try {
     process.chdir(workdir);
 
-    writeFileSync("foo.w", "bring cloud;");
+    writeFileSync("foo.main.w", "bring cloud;");
 
-    await run("foo.w", { port: "5000" });
+    await run("foo.main.w", { port: "5000" });
     expect(createConsoleApp).toBeCalledWith({
-      wingfile: resolve("foo.w"),
+      wingfile: resolve("foo.main.w"),
       requestedPort: 5000,
       hostUtils: expect.anything(),
       requireAcceptTerms: false,
@@ -141,10 +169,10 @@ test("wing it throws when invalid port number is used", async () => {
   try {
     process.chdir(workdir);
 
-    writeFileSync("foo.w", "bring cloud;");
+    writeFileSync("foo.main.w", "bring cloud;");
 
     await expect(async () => {
-      await run("foo.w", { port: "not a number" });
+      await run("foo.main.w", { port: "not a number" });
     }).rejects.toThrowError('"not a number" is not a number');
   } finally {
     process.chdir(prevdir);

apps/wing/src/commands/run.ts

@@ -1,7 +1,8 @@
-import { readdirSync, existsSync } from "fs";
+import { existsSync } from "fs";
 import { resolve } from "path";
 import { createConsoleApp } from "@wingconsole/app";
 import { debug } from "debug";
+import { glob } from "glob";
 import open from "open";
 import { parseNumericString } from "../util";
 
@@ -35,7 +36,7 @@ export async function run(entrypoint?: string, options?: RunOptions) {
   const openBrowser = options?.open ?? true;
 
   if (!entrypoint) {
-    const wingFiles = readdirSync(".").filter((item) => item.endsWith(".w"));
+    const wingFiles = await glob("{main,*.main}.w");
     if (wingFiles.length !== 1) {
       throw new Error("Please specify which file you want to run");
     }

apps/wing/src/commands/test.ts

@@ -1,11 +1,13 @@
 import * as cp from "child_process";
 import { readFile, rm, rmSync } from "fs";
+import * as os from "os";
 import { basename, resolve, sep } from "path";
 import { promisify } from "util";
 import { Target } from "@winglang/compiler";
 import { std, simulator } from "@winglang/sdk";
 import chalk from "chalk";
 import debug from "debug";
+import { glob } from "glob";
 import { nanoid } from "nanoid";
 import { compile, CompileOptions } from "./compile";
 import { generateTmpDir, withSpinner } from "../util";
@@ -29,6 +31,22 @@ export interface TestOptions extends CompileOptions {
 }
 
 export async function test(entrypoints: string[], options: TestOptions): Promise<number> {
+  let patterns;
+
+  if (entrypoints.length === 0) {
+    patterns = ["*.test.w"];
+  } else {
+    patterns =
+      os.platform() === "win32"
+        ? entrypoints.map((entrypoint) => entrypoint.replace(/\\/g, "/"))
+        : entrypoints;
+  }
+
+  const expandedEntrypoints = await glob(patterns);
+  if (expandedEntrypoints.length === 0) {
+    throw new Error(`No matching files found for patterns: [${patterns.join(", ")}]`);
+  }
+
   const startTime = Date.now();
   const results: { testName: string; results: std.TestResult[] }[] = [];
   const testFile = async (entrypoint: string) => {
@@ -44,7 +62,7 @@ export async function test(entrypoints: string[], options: TestOptions): Promise
       });
     }
   };
-  await Promise.all(entrypoints.map(testFile));
+  await Promise.all(expandedEntrypoints.map(testFile));
   printResults(results, Date.now() - startTime);
 
   // if we have any failures, exit with 1