tsonic 0.0.1

package/src/cli/dispatcher.ts

@@ -0,0 +1,115 @@
+/**
+ * CLI command dispatcher
+ */
+
+import { join } from "node:path";
+import { checkDotnetInstalled } from "@tsonic/backend";
+import { loadConfig, findConfig, resolveConfig } from "../config.js";
+import { initProject } from "../commands/init.js";
+import { emitCommand } from "../commands/emit.js";
+import { buildCommand } from "../commands/build.js";
+import { runCommand } from "../commands/run.js";
+import { VERSION } from "./constants.js";
+import { showHelp } from "./help.js";
+import { parseArgs } from "./parser.js";
+
+/**
+ * Main CLI entry point
+ */
+export const runCli = async (args: string[]): Promise<number> => {
+  const parsed = parseArgs(args);
+
+  // Handle version and help
+  if (parsed.command === "version") {
+    console.log(`tsonic v${VERSION}`);
+    return 0;
+  }
+
+  if (parsed.command === "help" || !parsed.command) {
+    showHelp();
+    return 0;
+  }
+
+  // Handle project init (doesn't need config)
+  if (parsed.command === "project:init") {
+    const result = initProject(process.cwd());
+    if (!result.ok) {
+      console.error(`Error: ${result.error}`);
+      return 1;
+    }
+    console.log("✓ Initialized Tsonic project");
+    console.log("  Created: tsonic.json");
+    console.log("  Created/Updated: .gitignore");
+    console.log("\nNext steps:");
+    console.log("  1. Edit tsonic.json to configure your project");
+    console.log("  2. Create src/main.ts");
+    console.log("  3. Run: tsonic build");
+    return 0;
+  }
+
+  // Check for dotnet
+  const dotnetResult = checkDotnetInstalled();
+  if (!dotnetResult.ok) {
+    console.error("Error: .NET SDK not found");
+    console.error("Install from: https://dotnet.microsoft.com/download");
+    return 8;
+  }
+
+  // Load config
+  const configPath = parsed.options.config
+    ? join(process.cwd(), parsed.options.config)
+    : findConfig(process.cwd());
+
+  if (!configPath) {
+    console.error("Error: No tsonic.json found");
+    console.error("Run 'tsonic project init' to initialize a project");
+    return 3;
+  }
+
+  const configResult = loadConfig(configPath);
+  if (!configResult.ok) {
+    console.error(`Error: ${configResult.error}`);
+    return 1;
+  }
+
+  const config = resolveConfig(
+    configResult.value,
+    parsed.options,
+    parsed.entryFile
+  );
+
+  // Dispatch to command handlers
+  switch (parsed.command) {
+    case "emit": {
+      const result = emitCommand(config);
+      if (!result.ok) {
+        console.error(`Error: ${result.error}`);
+        return 5;
+      }
+      return 0;
+    }
+
+    case "build": {
+      const result = buildCommand(config);
+      if (!result.ok) {
+        console.error(`Error: ${result.error}`);
+        return 6;
+      }
+      return 0;
+    }
+
+    case "run": {
+      const result = runCommand(config, parsed.programArgs ?? []);
+      if (!result.ok) {
+        console.error(`Error: ${result.error}`);
+        return 7;
+      }
+      return result.value.exitCode;
+    }
+
+    default:
+      console.error(`Error: Unknown command '${parsed.command}'`);
+      console.error("Run 'tsonic --help' for usage information");
+      return 2;
+  }
+};

package/src/cli/help.ts

@@ -0,0 +1,49 @@
+/**
+ * CLI help message
+ */
+
+import { VERSION } from "./constants.js";
+
+/**
+ * Show help message
+ */
+export const showHelp = (): void => {
+  console.log(`
+Tsonic - TypeScript to C# to NativeAOT compiler v${VERSION}
+
+USAGE:
+  tsonic <command> [options]
+
+COMMANDS:
+  project init              Initialize a new Tsonic project
+  emit [entry]              Generate C# code only
+  build [entry]             Build native executable
+  run [entry] [-- args...]  Build and run executable
+
+GLOBAL OPTIONS:
+  -h, --help                Show help
+  -v, --version             Show version
+  -V, --verbose             Verbose output
+  -q, --quiet               Suppress output
+  -c, --config <file>       Config file path (default: tsonic.json)
+
+EMIT/BUILD/RUN OPTIONS:
+  -s, --src <dir>           Source root directory
+  -o, --out <path>          Output directory (emit) or file (build)
+  -n, --namespace <ns>      Root namespace override
+  -r, --rid <rid>           Runtime identifier (e.g., linux-x64)
+  -O, --optimize <level>    Optimization: size or speed
+  -k, --keep-temp           Keep build artifacts
+  --no-strip                Keep debug symbols
+
+EXAMPLES:
+  tsonic project init
+  tsonic emit src/main.ts
+  tsonic build src/main.ts --rid linux-x64
+  tsonic run src/main.ts -- --arg1 value1
+
+LEARN MORE:
+  Documentation: https://tsonic.dev/docs
+  GitHub: https://github.com/tsoniclang/tsonic
+`);
+};

package/src/cli/index.ts

@@ -0,0 +1,8 @@
+/**
+ * CLI - Public API
+ */
+
+export { VERSION } from "./constants.js";
+export { showHelp } from "./help.js";
+export { parseArgs } from "./parser.js";
+export { runCli } from "./dispatcher.js";

package/src/cli/parser.test.ts

@@ -0,0 +1,259 @@
+/**
+ * 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

@@ -0,0 +1,109 @@
+/**
+ * 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 "-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;
+    }
+  }
+
+  return { command, entryFile, options, programArgs };
+};

package/src/cli.ts

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,125 @@
+/**
+ * tsonic build command - Build executable
+ */
+
+import { spawnSync } from "node:child_process";
+import { join, relative } from "node:path";
+import { copyFileSync, chmodSync, existsSync } from "node:fs";
+import type { ResolvedConfig, Result } from "../types.js";
+import { emitCommand } from "./emit.js";
+
+/**
+ * Build native executable
+ */
+export const buildCommand = (
+  config: ResolvedConfig
+): Result<{ outputPath: string }, string> => {
+  const { outputDirectory, outputName, rid, quiet, verbose } = config;
+
+  // 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.`,
+    };
+  }
+
+  // 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)}`,
+    };
+  }
+};