@tsonic/cli 0.0.1 → 0.0.3

package/src/cli/parser.test.ts

@@ -1,259 +0,0 @@
-/**
- * Tests for CLI argument parser
- */
-
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { parseArgs } from "./parser.js";
-
-describe("CLI Parser", () => {
-  describe("parseArgs", () => {
-    describe("Commands", () => {
-      it("should parse build command", () => {
-        const result = parseArgs(["build"]);
-        expect(result.command).to.equal("build");
-      });
-
-      it("should parse run command", () => {
-        const result = parseArgs(["run"]);
-        expect(result.command).to.equal("run");
-      });
-
-      it("should parse emit command", () => {
-        const result = parseArgs(["emit"]);
-        expect(result.command).to.equal("emit");
-      });
-
-      it("should parse project:init as two-word command", () => {
-        const result = parseArgs(["project", "init"]);
-        expect(result.command).to.equal("project:init");
-      });
-
-      it("should parse help command from --help", () => {
-        const result = parseArgs(["--help"]);
-        expect(result.command).to.equal("help");
-      });
-
-      it("should parse help command from -h", () => {
-        const result = parseArgs(["-h"]);
-        expect(result.command).to.equal("help");
-      });
-
-      it("should parse version command from --version", () => {
-        const result = parseArgs(["--version"]);
-        expect(result.command).to.equal("version");
-      });
-
-      it("should parse version command from -v", () => {
-        const result = parseArgs(["-v"]);
-        expect(result.command).to.equal("version");
-      });
-    });
-
-    describe("Entry File", () => {
-      it("should parse entry file after command", () => {
-        const result = parseArgs(["run", "index.ts"]);
-        expect(result.command).to.equal("run");
-        expect(result.entryFile).to.equal("index.ts");
-      });
-
-      it("should parse entry file with path", () => {
-        const result = parseArgs(["build", "src/main.ts"]);
-        expect(result.command).to.equal("build");
-        expect(result.entryFile).to.equal("src/main.ts");
-      });
-
-      it("should handle no entry file", () => {
-        const result = parseArgs(["build"]);
-        expect(result.entryFile).to.equal(undefined);
-      });
-    });
-
-    describe("Options", () => {
-      it("should parse --verbose option", () => {
-        const result = parseArgs(["build", "--verbose"]);
-        expect(result.options.verbose).to.equal(true);
-      });
-
-      it("should parse -V short option for verbose", () => {
-        const result = parseArgs(["build", "-V"]);
-        expect(result.options.verbose).to.equal(true);
-      });
-
-      it("should parse --quiet option", () => {
-        const result = parseArgs(["build", "--quiet"]);
-        expect(result.options.quiet).to.equal(true);
-      });
-
-      it("should parse -q short option for quiet", () => {
-        const result = parseArgs(["build", "-q"]);
-        expect(result.options.quiet).to.equal(true);
-      });
-
-      it("should parse --config option with value", () => {
-        const result = parseArgs(["build", "--config", "tsonic.json"]);
-        expect(result.options.config).to.equal("tsonic.json");
-      });
-
-      it("should parse -c short option for config", () => {
-        const result = parseArgs(["build", "-c", "custom.json"]);
-        expect(result.options.config).to.equal("custom.json");
-      });
-
-      it("should parse --src option with value", () => {
-        const result = parseArgs(["build", "--src", "source"]);
-        expect(result.options.src).to.equal("source");
-      });
-
-      it("should parse -s short option for src", () => {
-        const result = parseArgs(["build", "-s", "app"]);
-        expect(result.options.src).to.equal("app");
-      });
-
-      it("should parse --out option with value", () => {
-        const result = parseArgs(["build", "--out", "output"]);
-        expect(result.options.out).to.equal("output");
-      });
-
-      it("should parse -o short option for out", () => {
-        const result = parseArgs(["build", "-o", "dist"]);
-        expect(result.options.out).to.equal("dist");
-      });
-
-      it("should parse --namespace option with value", () => {
-        const result = parseArgs(["build", "--namespace", "MyApp"]);
-        expect(result.options.namespace).to.equal("MyApp");
-      });
-
-      it("should parse -n short option for namespace", () => {
-        const result = parseArgs(["build", "-n", "App"]);
-        expect(result.options.namespace).to.equal("App");
-      });
-
-      it("should parse --rid option with value", () => {
-        const result = parseArgs(["build", "--rid", "linux-x64"]);
-        expect(result.options.rid).to.equal("linux-x64");
-      });
-
-      it("should parse -r short option for rid", () => {
-        const result = parseArgs(["build", "-r", "win-x64"]);
-        expect(result.options.rid).to.equal("win-x64");
-      });
-
-      it("should parse --optimize option with speed", () => {
-        const result = parseArgs(["build", "--optimize", "speed"]);
-        expect(result.options.optimize).to.equal("speed");
-      });
-
-      it("should parse --optimize option with size", () => {
-        const result = parseArgs(["build", "--optimize", "size"]);
-        expect(result.options.optimize).to.equal("size");
-      });
-
-      it("should parse -O short option for optimize", () => {
-        const result = parseArgs(["build", "-O", "speed"]);
-        expect(result.options.optimize).to.equal("speed");
-      });
-
-      it("should parse --keep-temp option", () => {
-        const result = parseArgs(["build", "--keep-temp"]);
-        expect(result.options.keepTemp).to.equal(true);
-      });
-
-      it("should parse -k short option for keep-temp", () => {
-        const result = parseArgs(["build", "-k"]);
-        expect(result.options.keepTemp).to.equal(true);
-      });
-
-      it("should parse --no-strip option", () => {
-        const result = parseArgs(["build", "--no-strip"]);
-        expect(result.options.noStrip).to.equal(true);
-      });
-    });
-
-    describe("Program Arguments", () => {
-      it("should parse program arguments after --", () => {
-        const result = parseArgs(["run", "index.ts", "--", "arg1", "arg2"]);
-        expect(result.programArgs).to.deep.equal(["arg1", "arg2"]);
-      });
-
-      it("should handle options in program arguments", () => {
-        const result = parseArgs([
-          "run",
-          "index.ts",
-          "--",
-          "--verbose",
-          "-o",
-          "out",
-        ]);
-        expect(result.programArgs).to.deep.equal(["--verbose", "-o", "out"]);
-      });
-
-      it("should handle empty program arguments", () => {
-        const result = parseArgs(["run", "index.ts"]);
-        expect(result.programArgs).to.deep.equal([]);
-      });
-    });
-
-    describe("Complex Scenarios", () => {
-      it("should parse command with entry file and multiple options", () => {
-        const result = parseArgs([
-          "build",
-          "src/main.ts",
-          "--namespace",
-          "MyApp",
-          "--out",
-          "dist",
-          "--verbose",
-        ]);
-        expect(result.command).to.equal("build");
-        expect(result.entryFile).to.equal("src/main.ts");
-        expect(result.options.namespace).to.equal("MyApp");
-        expect(result.options.out).to.equal("dist");
-        expect(result.options.verbose).to.equal(true);
-      });
-
-      it("should parse run command with entry, options, and program args", () => {
-        const result = parseArgs([
-          "run",
-          "index.ts",
-          "--verbose",
-          "--",
-          "programArg1",
-          "programArg2",
-        ]);
-        expect(result.command).to.equal("run");
-        expect(result.entryFile).to.equal("index.ts");
-        expect(result.options.verbose).to.equal(true);
-        expect(result.programArgs).to.deep.equal([
-          "programArg1",
-          "programArg2",
-        ]);
-      });
-
-      it("should handle empty args array", () => {
-        const result = parseArgs([]);
-        expect(result.command).to.equal("");
-        expect(result.entryFile).to.equal(undefined);
-        expect(result.options).to.deep.equal({});
-        expect(result.programArgs).to.deep.equal([]);
-      });
-
-      it("should handle mixed short and long options", () => {
-        const result = parseArgs([
-          "build",
-          "-n",
-          "App",
-          "--out",
-          "dist",
-          "-V",
-          "--keep-temp",
-        ]);
-        expect(result.options.namespace).to.equal("App");
-        expect(result.options.out).to.equal("dist");
-        expect(result.options.verbose).to.equal(true);
-        expect(result.options.keepTemp).to.equal(true);
-      });
-    });
-  });
-});

package/src/cli/parser.ts

@@ -1,128 +0,0 @@
-/**
- * CLI argument parser
- */
-
-import type { CliOptions } from "../types.js";
-
-/**
- * Parse CLI arguments
- */
-export const parseArgs = (
-  args: string[]
-): {
-  command: string;
-  entryFile?: string;
-  options: CliOptions;
-  programArgs?: string[];
-} => {
-  const options: CliOptions = {};
-  let command = "";
-  let entryFile: string | undefined;
-  const programArgs: string[] = [];
-  let captureProgramArgs = false;
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (!arg) continue; // Skip if undefined
-
-    // Separator for program arguments
-    if (arg === "--") {
-      captureProgramArgs = true;
-      continue;
-    }
-
-    if (captureProgramArgs) {
-      programArgs.push(arg);
-      continue;
-    }
-
-    // Commands
-    if (!command && !arg.startsWith("-")) {
-      command = arg;
-      // Handle "project init" as two-word command
-      const nextArg = args[i + 1];
-      if (command === "project" && nextArg === "init") {
-        command = "project:init";
-        i++;
-      }
-      continue;
-    }
-
-    // Entry file (first non-option after command)
-    if (command && !entryFile && !arg.startsWith("-")) {
-      entryFile = arg;
-      continue;
-    }
-
-    // Options
-    switch (arg) {
-      case "-h":
-      case "--help":
-        options.verbose = true; // reuse for help flag
-        return { command: "help", options: {} };
-      case "-v":
-      case "--version":
-        return { command: "version", options: {} };
-      case "-V":
-      case "--verbose":
-        options.verbose = true;
-        break;
-      case "-q":
-      case "--quiet":
-        options.quiet = true;
-        break;
-      case "-c":
-      case "--config":
-        options.config = args[++i] ?? "";
-        break;
-      case "-s":
-      case "--src":
-        options.src = args[++i] ?? "";
-        break;
-      case "-o":
-      case "--out":
-        options.out = args[++i] ?? "";
-        break;
-      case "-n":
-      case "--namespace":
-        options.namespace = args[++i] ?? "";
-        break;
-      case "-r":
-      case "--rid":
-        options.rid = args[++i] ?? "";
-        break;
-      case "--runtime":
-        options.runtime = (args[++i] ?? "js") as "js" | "dotnet";
-        break;
-      case "--skip-types":
-        options.skipTypes = true;
-        break;
-      case "--types-version":
-        options.typesVersion = args[++i] ?? "";
-        break;
-      case "-O":
-      case "--optimize":
-        options.optimize = (args[++i] ?? "speed") as "size" | "speed";
-        break;
-      case "-k":
-      case "--keep-temp":
-        options.keepTemp = true;
-        break;
-      case "--no-strip":
-        options.noStrip = true;
-        break;
-      case "-L":
-      case "--lib":
-        {
-          const libPath = args[++i] ?? "";
-          if (libPath) {
-            options.lib = options.lib || [];
-            options.lib.push(libPath);
-          }
-        }
-        break;
-    }
-  }
-
-  return { command, entryFile, options, programArgs };
-};

package/src/cli.ts

@@ -1,6 +0,0 @@
-/**
- * CLI argument parsing and command dispatch
- * Main dispatcher - re-exports from cli/ subdirectory
- */
-
-export { VERSION, showHelp, parseArgs, runCli } from "./cli/index.js";

package/src/commands/build.ts

@@ -1,264 +0,0 @@
-/**
- * tsonic build command - Build executable or library
- */
-
-import { spawnSync } from "node:child_process";
-import { join, relative } from "node:path";
-import { copyFileSync, chmodSync, existsSync, mkdirSync } from "node:fs";
-import type { ResolvedConfig, Result } from "../types.js";
-import { emitCommand } from "./emit.js";
-
-/**
- * Build native executable
- */
-const buildExecutable = (
-  config: ResolvedConfig,
-  generatedDir: string
-): Result<{ outputPath: string }, string> => {
-  const { outputName, rid, quiet, verbose } = config;
-
-  // Step 2: Run dotnet publish
-  if (!quiet) {
-    console.log("Step 2/3: Compiling with dotnet publish...");
-  }
-
-  const publishArgs = [
-    "publish",
-    "tsonic.csproj",
-    "-c",
-    "Release",
-    "-r",
-    rid,
-    "--nologo",
-  ];
-
-  if (quiet) {
-    publishArgs.push("--verbosity", "quiet");
-  } else if (verbose) {
-    publishArgs.push("--verbosity", "detailed");
-  } else {
-    publishArgs.push("--verbosity", "minimal");
-  }
-
-  const publishResult = spawnSync("dotnet", publishArgs, {
-    cwd: generatedDir,
-    stdio: verbose ? "inherit" : "pipe",
-    encoding: "utf-8",
-  });
-
-  if (publishResult.status !== 0) {
-    const errorMsg =
-      publishResult.stderr || publishResult.stdout || "Unknown error";
-    return {
-      ok: false,
-      error: `dotnet publish failed:\n${errorMsg}`,
-    };
-  }
-
-  // Step 3: Copy output binary
-  if (!quiet) {
-    console.log("Step 3/3: Copying output binary...");
-  }
-
-  const binaryName =
-    process.platform === "win32" ? `${outputName}.exe` : outputName;
-  const publishDir = join(
-    generatedDir,
-    "bin",
-    "Release",
-    config.dotnetVersion,
-    rid,
-    "publish"
-  );
-  const sourceBinary = join(publishDir, binaryName);
-  const targetBinary = join(process.cwd(), binaryName);
-
-  if (!existsSync(sourceBinary)) {
-    return {
-      ok: false,
-      error: `Built binary not found at ${sourceBinary}`,
-    };
-  }
-
-  try {
-    copyFileSync(sourceBinary, targetBinary);
-
-    // Make executable on Unix
-    if (process.platform !== "win32") {
-      chmodSync(targetBinary, 0o755);
-    }
-
-    if (!quiet) {
-      const relativePath = relative(process.cwd(), targetBinary);
-      console.log(`\n✓ Build complete: ${relativePath}`);
-    }
-
-    return {
-      ok: true,
-      value: { outputPath: targetBinary },
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      error: `Failed to copy binary: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-};
-
-/**
- * Build library
- */
-const buildLibrary = (
-  config: ResolvedConfig,
-  generatedDir: string
-): Result<{ outputPath: string }, string> => {
-  const { outputName, quiet, verbose } = config;
-  const targetFrameworks = config.outputConfig.targetFrameworks ?? [
-    config.dotnetVersion,
-  ];
-
-  // Step 2: Run dotnet build
-  if (!quiet) {
-    console.log("Step 2/3: Compiling library with dotnet build...");
-  }
-
-  const buildArgs = ["build", "tsonic.csproj", "-c", "Release", "--nologo"];
-
-  if (quiet) {
-    buildArgs.push("--verbosity", "quiet");
-  } else if (verbose) {
-    buildArgs.push("--verbosity", "detailed");
-  } else {
-    buildArgs.push("--verbosity", "minimal");
-  }
-
-  const buildResult = spawnSync("dotnet", buildArgs, {
-    cwd: generatedDir,
-    stdio: verbose ? "inherit" : "pipe",
-    encoding: "utf-8",
-  });
-
-  if (buildResult.status !== 0) {
-    const errorMsg =
-      buildResult.stderr || buildResult.stdout || "Unknown error";
-    return {
-      ok: false,
-      error: `dotnet build failed:\n${errorMsg}`,
-    };
-  }
-
-  // Step 3: Copy output library artifacts
-  if (!quiet) {
-    console.log("Step 3/3: Copying library artifacts...");
-  }
-
-  const outputDir = join(process.cwd(), "dist");
-
-  try {
-    // Create output directory
-    if (!existsSync(outputDir)) {
-      mkdirSync(outputDir, { recursive: true });
-    }
-
-    // Copy artifacts for each target framework
-    const copiedFiles: string[] = [];
-
-    for (const framework of targetFrameworks) {
-      const buildDir = join(generatedDir, "bin", "Release", framework);
-
-      if (!existsSync(buildDir)) {
-        continue;
-      }
-
-      const frameworkOutputDir = join(outputDir, framework);
-      if (!existsSync(frameworkOutputDir)) {
-        mkdirSync(frameworkOutputDir, { recursive: true });
-      }
-
-      // Copy .dll
-      const dllSource = join(buildDir, `${outputName}.dll`);
-      if (existsSync(dllSource)) {
-        const dllTarget = join(frameworkOutputDir, `${outputName}.dll`);
-        copyFileSync(dllSource, dllTarget);
-        copiedFiles.push(relative(process.cwd(), dllTarget));
-      }
-
-      // Copy .xml (documentation)
-      const xmlSource = join(buildDir, `${outputName}.xml`);
-      if (existsSync(xmlSource)) {
-        const xmlTarget = join(frameworkOutputDir, `${outputName}.xml`);
-        copyFileSync(xmlSource, xmlTarget);
-        copiedFiles.push(relative(process.cwd(), xmlTarget));
-      }
-
-      // Copy .pdb (symbols)
-      const pdbSource = join(buildDir, `${outputName}.pdb`);
-      if (existsSync(pdbSource)) {
-        const pdbTarget = join(frameworkOutputDir, `${outputName}.pdb`);
-        copyFileSync(pdbSource, pdbTarget);
-        copiedFiles.push(relative(process.cwd(), pdbTarget));
-      }
-    }
-
-    if (copiedFiles.length === 0) {
-      return {
-        ok: false,
-        error: "No library artifacts found to copy",
-      };
-    }
-
-    if (!quiet) {
-      console.log(`\n✓ Build complete. Artifacts copied to dist/:`);
-      for (const file of copiedFiles) {
-        console.log(`  - ${file}`);
-      }
-    }
-
-    return {
-      ok: true,
-      value: { outputPath: outputDir },
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      error: `Failed to copy library artifacts: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-};
-
-/**
- * Main build command - dispatches to executable or library build
- */
-export const buildCommand = (
-  config: ResolvedConfig
-): Result<{ outputPath: string }, string> => {
-  const { outputDirectory, quiet } = config;
-  const outputType = config.outputConfig.type ?? "executable";
-
-  // Step 1: Emit C# code
-  if (!quiet) {
-    console.log("Step 1/3: Generating C# code...");
-  }
-
-  const emitResult = emitCommand(config);
-  if (!emitResult.ok) {
-    return emitResult;
-  }
-
-  const generatedDir = emitResult.value.outputDir;
-  const csprojPath = join(generatedDir, "tsonic.csproj");
-
-  if (!existsSync(csprojPath)) {
-    return {
-      ok: false,
-      error: `No tsonic.csproj found in ${outputDirectory}/. This should have been created by emit.`,
-    };
-  }
-
-  // Dispatch to appropriate build function
-  if (outputType === "library") {
-    return buildLibrary(config, generatedDir);
-  } else {
-    return buildExecutable(config, generatedDir);
-  }
-};