@tsonic/cli 0.0.1

package/src/commands/build.ts

@@ -0,0 +1,264 @@
+/**
+ * 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);
+  }
+};

package/src/commands/emit.ts

@@ -0,0 +1,406 @@
+/**
+ * tsonic emit command - Generate C# code only
+ */
+
+import {
+  mkdirSync,
+  writeFileSync,
+  existsSync,
+  readdirSync,
+  copyFileSync,
+} from "node:fs";
+import { join, dirname, relative, resolve } from "node:path";
+import {
+  buildModuleDependencyGraph,
+  type Diagnostic,
+  type IrModule,
+  type CompilerOptions,
+} from "@tsonic/frontend";
+import { emitCSharpFiles } from "@tsonic/emitter";
+import {
+  generateCsproj,
+  generateProgramCs,
+  type EntryInfo,
+  type BuildConfig,
+  type ExecutableConfig,
+  type LibraryConfig,
+  type AssemblyReference,
+} from "@tsonic/backend";
+import type { ResolvedConfig, Result } from "../types.js";
+
+/**
+ * Find project .csproj file in current directory
+ */
+const findProjectCsproj = (): string | null => {
+  const cwd = process.cwd();
+  const files = readdirSync(cwd);
+  const csprojFile = files.find((f) => f.endsWith(".csproj"));
+  return csprojFile ? join(cwd, csprojFile) : null;
+};
+
+/**
+ * Find runtime DLLs from @tsonic/tsonic npm package
+ * Returns assembly references for the csproj file
+ */
+const findRuntimeDlls = (
+  runtime: "js" | "dotnet",
+  outputDir: string
+): readonly AssemblyReference[] => {
+  // Try to find @tsonic/tsonic package runtime directory
+  const possiblePaths = [
+    // From project's node_modules
+    join(process.cwd(), "node_modules/@tsonic/tsonic/runtime"),
+    // From CLI's node_modules (when installed globally or via npx)
+    join(import.meta.dirname, "../../runtime"),
+    join(import.meta.dirname, "../../../runtime"),
+  ];
+
+  let runtimeDir: string | null = null;
+  for (const p of possiblePaths) {
+    if (existsSync(p)) {
+      runtimeDir = p;
+      break;
+    }
+  }
+
+  if (!runtimeDir) {
+    return [];
+  }
+
+  const refs: AssemblyReference[] = [];
+
+  // Calculate relative path from output directory to runtime directory
+  const relativeRuntimeDir = relative(outputDir, runtimeDir);
+
+  // Always include Tsonic.Runtime
+  const runtimeDll = join(runtimeDir, "Tsonic.Runtime.dll");
+  if (existsSync(runtimeDll)) {
+    refs.push({
+      name: "Tsonic.Runtime",
+      hintPath: join(relativeRuntimeDir, "Tsonic.Runtime.dll"),
+    });
+  }
+
+  // Include Tsonic.JSRuntime for js mode
+  if (runtime === "js") {
+    const jsRuntimeDll = join(runtimeDir, "Tsonic.JSRuntime.dll");
+    if (existsSync(jsRuntimeDll)) {
+      refs.push({
+        name: "Tsonic.JSRuntime",
+        hintPath: join(relativeRuntimeDir, "Tsonic.JSRuntime.dll"),
+      });
+    }
+  }
+
+  return refs;
+};
+
+/**
+ * Extract entry point information from IR module
+ */
+const extractEntryInfo = (
+  entryModule: IrModule,
+  runtime?: "js" | "dotnet"
+): EntryInfo | null => {
+  // Look for exported 'main' function
+  for (const exp of entryModule.exports) {
+    if (exp.kind === "declaration") {
+      const decl = exp.declaration;
+      if (decl.kind === "functionDeclaration" && decl.name === "main") {
+        return {
+          namespace: entryModule.namespace,
+          className: entryModule.className,
+          methodName: "main",
+          isAsync: decl.isAsync,
+          needsProgram: true,
+          runtime,
+        };
+      }
+    } else if (exp.kind === "named" && exp.name === "main") {
+      // Named export of 'main'
+      // Look in body for the function declaration
+      for (const stmt of entryModule.body) {
+        if (stmt.kind === "functionDeclaration" && stmt.name === "main") {
+          return {
+            namespace: entryModule.namespace,
+            className: entryModule.className,
+            methodName: "main",
+            isAsync: stmt.isAsync,
+            needsProgram: true,
+            runtime,
+          };
+        }
+      }
+    }
+  }
+
+  // No main function found
+  return null;
+};
+
+/**
+ * Emit C# code from TypeScript
+ */
+export const emitCommand = (
+  config: ResolvedConfig
+): Result<{ filesGenerated: number; outputDir: string }, string> => {
+  const {
+    entryPoint,
+    outputDirectory,
+    rootNamespace,
+    sourceRoot,
+    packages,
+    typeRoots,
+  } = config;
+
+  // For libraries, entry point is optional
+  if (!entryPoint && config.outputConfig.type !== "library") {
+    return {
+      ok: false,
+      error: "Entry point is required for executable builds",
+    };
+  }
+
+  if (!config.quiet) {
+    const target = entryPoint ?? sourceRoot;
+    console.log(`Emitting C# code for ${target}...`);
+  }
+
+  try {
+    // For libraries without entry point, we need a different approach
+    // For now, require entry point (library multi-file support can be added later)
+    if (!entryPoint) {
+      return {
+        ok: false,
+        error:
+          "Entry point is required (library multi-file support coming soon)",
+      };
+    }
+
+    // Combine typeRoots and libraries for TypeScript compilation
+    const allTypeRoots = [...typeRoots, ...config.libraries];
+
+    // Build dependency graph - this traverses all imports and builds IR for all modules
+    const compilerOptions: CompilerOptions = {
+      sourceRoot,
+      rootNamespace,
+      typeRoots: allTypeRoots,
+      verbose: config.verbose,
+    };
+    const graphResult = buildModuleDependencyGraph(entryPoint, compilerOptions);
+
+    if (!graphResult.ok) {
+      const errorMessages = graphResult.error
+        .map((d: Diagnostic) => {
+          if (d.location) {
+            return `${d.location.file}:${d.location.line} ${d.message}`;
+          }
+          return d.message;
+        })
+        .join("\n");
+      return {
+        ok: false,
+        error: `TypeScript compilation failed:\n${errorMessages}`,
+      };
+    }
+
+    const { modules, entryModule } = graphResult.value;
+
+    if (config.verbose) {
+      console.log(`  Discovered ${modules.length} TypeScript modules`);
+      for (const module of modules) {
+        console.log(`    - ${module.filePath}`);
+      }
+    }
+
+    // irResult.value was an array of modules, now it's graphResult.value.modules
+    const irResult = { ok: true as const, value: modules };
+
+    // Emit C# code
+    const absoluteEntryPoint = entryPoint ? resolve(entryPoint) : undefined;
+    const emitResult = emitCSharpFiles(irResult.value, {
+      rootNamespace,
+      entryPointPath: absoluteEntryPoint,
+      libraries: config.libraries,
+      runtime: config.runtime,
+    });
+
+    if (!emitResult.ok) {
+      // Handle file name collision errors
+      for (const error of emitResult.errors) {
+        console.error(`error ${error.code}: ${error.message}`);
+      }
+      process.exit(1);
+    }
+
+    const csFiles = emitResult.files;
+
+    // Create output directory
+    const outputDir = join(process.cwd(), outputDirectory);
+    mkdirSync(outputDir, { recursive: true });
+
+    // Write C# files preserving directory structure
+    for (const [modulePath, csCode] of csFiles) {
+      // Convert module path to C# file path
+      // src/models/User.ts → generated/src/models/User.cs
+      const csPath = modulePath.replace(/\.ts$/, ".cs");
+      const fullPath = join(outputDir, csPath);
+
+      mkdirSync(dirname(fullPath), { recursive: true });
+      writeFileSync(fullPath, csCode, "utf-8");
+
+      if (config.verbose) {
+        const relPath = relative(process.cwd(), fullPath);
+        console.log(`  Generated: ${relPath}`);
+      }
+    }
+
+    // Generate Program.cs entry point wrapper (only for executables)
+    if (absoluteEntryPoint) {
+      // entryModule is already provided by buildDependencyGraph
+      // But double-check by comparing relative paths
+      const entryRelative = relative(sourceRoot, absoluteEntryPoint).replace(
+        /\\/g,
+        "/"
+      );
+      const foundEntryModule =
+        irResult.value.find((m: IrModule) => m.filePath === entryRelative) ??
+        entryModule;
+
+      if (foundEntryModule) {
+        const entryInfo = extractEntryInfo(foundEntryModule, config.runtime);
+        if (entryInfo) {
+          const programCs = generateProgramCs(entryInfo);
+          const programPath = join(outputDir, "Program.cs");
+          writeFileSync(programPath, programCs, "utf-8");
+
+          if (config.verbose) {
+            console.log(`  Generated: ${relative(process.cwd(), programPath)}`);
+          }
+        }
+      }
+    }
+
+    // Generate or copy existing .csproj
+    const csprojPath = join(outputDir, "tsonic.csproj");
+    const projectCsproj = findProjectCsproj();
+
+    if (projectCsproj) {
+      // Copy existing .csproj from project root (preserves user edits)
+      copyFileSync(projectCsproj, csprojPath);
+
+      if (config.verbose) {
+        console.log(
+          `  Copied: ${relative(process.cwd(), projectCsproj)} → ${relative(process.cwd(), csprojPath)} (user edits preserved)`
+        );
+      }
+    } else if (!existsSync(csprojPath)) {
+      // Find Tsonic runtime - try multiple approaches:
+      // 1. ProjectReference to .csproj (development/monorepo)
+      // 2. Assembly references to DLLs (npm installed package)
+      let runtimePath: string | undefined;
+      let assemblyReferences: readonly AssemblyReference[] = [];
+
+      // 1. Try monorepo structure (development) - ProjectReference
+      const monorepoPath = resolve(
+        join(import.meta.dirname, "../../../runtime/src/Tsonic.Runtime.csproj")
+      );
+      if (existsSync(monorepoPath)) {
+        runtimePath = monorepoPath;
+      } else {
+        // 2. Try installed package structure - ProjectReference
+        const installedPath = resolve(
+          join(
+            import.meta.dirname,
+            "../../../../@tsonic/runtime/src/Tsonic.Runtime.csproj"
+          )
+        );
+        if (existsSync(installedPath)) {
+          runtimePath = installedPath;
+        } else {
+          // 3. Try to find runtime DLLs from npm package
+          assemblyReferences = findRuntimeDlls(
+            config.runtime ?? "js",
+            outputDir
+          );
+        }
+      }
+
+      // Warn if no runtime found
+      if (!runtimePath && assemblyReferences.length === 0 && !config.quiet) {
+        console.warn(
+          "Warning: Tsonic runtime not found. You may need to add references manually."
+        );
+      }
+
+      // Build output configuration
+      const outputType = config.outputConfig.type ?? "executable";
+      let outputConfig: ExecutableConfig | LibraryConfig;
+
+      if (outputType === "library") {
+        outputConfig = {
+          type: "library",
+          targetFrameworks: config.outputConfig.targetFrameworks ?? [
+            config.dotnetVersion,
+          ],
+          generateDocumentation:
+            config.outputConfig.generateDocumentation ?? true,
+          includeSymbols: config.outputConfig.includeSymbols ?? true,
+          packable: config.outputConfig.packable ?? false,
+          packageMetadata: config.outputConfig.package,
+        };
+      } else {
+        outputConfig = {
+          type: "executable",
+          nativeAot: config.outputConfig.nativeAot ?? true,
+          singleFile: config.outputConfig.singleFile ?? true,
+          trimmed: config.outputConfig.trimmed ?? true,
+          stripSymbols: config.stripSymbols,
+          optimization: config.optimize === "size" ? "Size" : "Speed",
+          invariantGlobalization: config.invariantGlobalization,
+          selfContained: config.outputConfig.selfContained ?? true,
+        };
+      }
+
+      const buildConfig: BuildConfig = {
+        rootNamespace,
+        outputName: config.outputName,
+        dotnetVersion: config.dotnetVersion,
+        runtimePath,
+        assemblyReferences,
+        packages,
+        outputConfig,
+      };
+
+      const csproj = generateCsproj(buildConfig);
+      writeFileSync(csprojPath, csproj, "utf-8");
+
+      if (config.verbose) {
+        console.log(`  Generated: ${relative(process.cwd(), csprojPath)}`);
+      }
+    } else if (config.verbose) {
+      console.log(
+        `  Preserved: ${relative(process.cwd(), csprojPath)} (user edits kept)`
+      );
+    }
+
+    if (!config.quiet) {
+      console.log(
+        `\n✓ Generated ${csFiles.size} C# files in ${outputDirectory}/`
+      );
+    }
+
+    return {
+      ok: true,
+      value: {
+        filesGenerated: csFiles.size,
+        outputDir,
+      },
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Emit failed: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+};