tsonic 0.0.1 → 0.0.12

package/src/commands/emit.ts

@@ -1,222 +0,0 @@
-/**
- * tsonic emit command - Generate C# code only
- */
-
-import { mkdirSync, writeFileSync, existsSync } from "node:fs";
-import { join, dirname, relative, resolve } from "node:path";
-import {
-  compile,
-  buildIr,
-  type Diagnostic,
-  type IrModule,
-} from "@tsonic/frontend";
-import { emitCSharpFiles } from "@tsonic/emitter";
-import {
-  generateCsproj,
-  generateProgramCs,
-  type EntryInfo,
-} from "@tsonic/backend";
-import type { ResolvedConfig, Result } from "../types.js";
-
-/**
- * Extract entry point information from IR module
- */
-const extractEntryInfo = (entryModule: IrModule): 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,
-        };
-      }
-    } 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,
-          };
-        }
-      }
-    }
-  }
-
-  // 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;
-
-  if (!config.quiet) {
-    console.log(`Emitting C# code for ${entryPoint}...`);
-  }
-
-  try {
-    // Parse TypeScript
-    const compileResult = compile([entryPoint], {
-      sourceRoot,
-      rootNamespace,
-      typeRoots,
-    });
-    if (!compileResult.ok) {
-      return {
-        ok: false,
-        error: `TypeScript compilation failed:\n${compileResult.error.diagnostics.map((d: Diagnostic) => d.message).join("\n")}`,
-      };
-    }
-
-    // Build IR
-    const irResult = buildIr(compileResult.value.program, {
-      sourceRoot,
-      rootNamespace,
-    });
-
-    if (!irResult.ok) {
-      return {
-        ok: false,
-        error: `IR build failed:\n${irResult.error.map((d: Diagnostic) => d.message).join("\n")}`,
-      };
-    }
-
-    // Emit C# code
-    const absoluteEntryPoint = resolve(entryPoint);
-    const csFiles = emitCSharpFiles(irResult.value, {
-      rootNamespace,
-      entryPointPath: absoluteEntryPoint,
-    });
-
-    // 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
-    const entryModule = irResult.value.find(
-      (m) => resolve(m.filePath) === absoluteEntryPoint
-    );
-
-    if (entryModule) {
-      const entryInfo = extractEntryInfo(entryModule);
-      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 preserve tsonic.csproj
-    const csprojPath = join(outputDir, "tsonic.csproj");
-    if (!existsSync(csprojPath)) {
-      // Find Tsonic.Runtime.csproj path - try multiple locations
-      let runtimePath: string | undefined;
-
-      // 1. Try monorepo structure (development)
-      const monorepoPath = resolve(
-        join(import.meta.dirname, "../../../runtime/src/Tsonic.Runtime.csproj")
-      );
-      if (existsSync(monorepoPath)) {
-        runtimePath = monorepoPath;
-      } else {
-        // 2. Try installed package structure
-        const installedPath = resolve(
-          join(
-            import.meta.dirname,
-            "../../../../@tsonic/runtime/src/Tsonic.Runtime.csproj"
-          )
-        );
-        if (existsSync(installedPath)) {
-          runtimePath = installedPath;
-        }
-      }
-
-      // Warn if no runtime found
-      if (!runtimePath && !config.quiet) {
-        console.warn(
-          "Warning: Tsonic.Runtime.csproj not found. You may need to add a reference manually."
-        );
-      }
-
-      const csproj = generateCsproj({
-        rootNamespace,
-        outputName: config.outputName,
-        dotnetVersion: config.dotnetVersion,
-        runtimePath,
-        packages,
-        invariantGlobalization: config.invariantGlobalization,
-        stripSymbols: config.stripSymbols,
-        optimizationPreference: config.optimize === "size" ? "Size" : "Speed",
-      });
-      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)}`,
-    };
-  }
-};

package/src/commands/init.ts

@@ -1,272 +0,0 @@
-/**
- * tsonic project init command
- */
-
-import { writeFileSync, existsSync, readFileSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { spawnSync } from "node:child_process";
-import type { Result } from "../types.js";
-
-type InitOptions = {
-  readonly skipTypes?: boolean;
-  readonly typesVersion?: string;
-};
-
-const DEFAULT_GITIGNORE = `# .NET build artifacts
-generated/bin/
-generated/obj/
-
-# Optional: Uncomment to ignore generated C# files
-# generated/**/*.cs
-
-# Output executables
-*.exe
-app
-
-# Dependencies
-node_modules/
-`;
-
-const SAMPLE_MAIN_TS = `import { Console } from "System";
-import { File } from "System.IO";
-
-export function main(): void {
-  Console.WriteLine("Reading README.md...");
-  const content = File.ReadAllText("./README.md");
-  Console.WriteLine(content);
-}
-`;
-
-const SAMPLE_README = `# My Tsonic Project
-
-This is a sample Tsonic project that demonstrates .NET interop.
-
-## Getting Started
-
-Build and run the project:
-
-\`\`\`bash
-npm run build
-./app
-\`\`\`
-
-Or run directly:
-
-\`\`\`bash
-npm run dev
-\`\`\`
-
-## Project Structure
-
-- \`src/main.ts\` - Entry point
-- \`tsonic.json\` - Project configuration
-- \`generated/\` - Generated C# code (gitignored)
-`;
-
-/**
- * Generate tsonic.json config
- */
-const generateConfig = (includeTypeRoots: boolean): string => {
-  const config: Record<string, unknown> = {
-    $schema: "https://tsonic.dev/schema/v1.json",
-    rootNamespace: "MyApp",
-    entryPoint: "src/main.ts",
-    sourceRoot: "src",
-    outputDirectory: "generated",
-    outputName: "app",
-    optimize: "speed",
-    packages: [],
-    buildOptions: {
-      stripSymbols: true,
-      invariantGlobalization: true,
-    },
-  };
-
-  if (includeTypeRoots) {
-    config.dotnet = {
-      typeRoots: ["node_modules/@tsonic/dotnet-types/types"],
-    };
-  }
-
-  return JSON.stringify(config, null, 2) + "\n";
-};
-
-/**
- * Create or update package.json with scripts and metadata
- */
-const createOrUpdatePackageJson = (packageJsonPath: string): void => {
-  let packageJson: Record<string, unknown>;
-
-  if (existsSync(packageJsonPath)) {
-    // Merge with existing package.json
-    const existing = readFileSync(packageJsonPath, "utf-8");
-    packageJson = JSON.parse(existing);
-
-    // Ensure required fields exist
-    if (!packageJson.name) {
-      packageJson.name = "my-tsonic-app";
-    }
-    if (!packageJson.version) {
-      packageJson.version = "1.0.0";
-    }
-    if (!packageJson.type) {
-      packageJson.type = "module";
-    }
-
-    // Merge scripts
-    const existingScripts =
-      (packageJson.scripts as Record<string, string>) || {};
-    packageJson.scripts = {
-      ...existingScripts,
-      build: "tsonic build src/main.ts",
-      dev: "tsonic run src/main.ts",
-    };
-
-    // Ensure devDependencies exists
-    if (!packageJson.devDependencies) {
-      packageJson.devDependencies = {};
-    }
-  } else {
-    // Create new package.json
-    packageJson = {
-      name: "my-tsonic-app",
-      version: "1.0.0",
-      type: "module",
-      scripts: {
-        build: "tsonic build src/main.ts",
-        dev: "tsonic run src/main.ts",
-      },
-      devDependencies: {},
-    };
-  }
-
-  writeFileSync(
-    packageJsonPath,
-    JSON.stringify(packageJson, null, 2) + "\n",
-    "utf-8"
-  );
-};
-
-/**
- * Install npm package
- */
-const installPackage = (
-  packageName: string,
-  version: string
-): Result<void, string> => {
-  const result = spawnSync(
-    "npm",
-    ["install", "--save-dev", `${packageName}@${version}`],
-    {
-      stdio: "inherit",
-      encoding: "utf-8",
-    }
-  );
-
-  if (result.status !== 0) {
-    return {
-      ok: false,
-      error: `Failed to install ${packageName}@${version}`,
-    };
-  }
-
-  return { ok: true, value: undefined };
-};
-
-/**
- * Initialize a new Tsonic project
- */
-export const initProject = (
-  cwd: string,
-  options: InitOptions = {}
-): Result<void, string> => {
-  const tsonicJsonPath = join(cwd, "tsonic.json");
-  const gitignorePath = join(cwd, ".gitignore");
-  const srcDir = join(cwd, "src");
-  const mainTsPath = join(srcDir, "main.ts");
-  const readmePath = join(cwd, "README.md");
-  const packageJsonPath = join(cwd, "package.json");
-
-  // Check if tsonic.json already exists
-  if (existsSync(tsonicJsonPath)) {
-    return {
-      ok: false,
-      error: "tsonic.json already exists. Project is already initialized.",
-    };
-  }
-
-  try {
-    // Create or update package.json FIRST (before npm install)
-    const packageJsonExists = existsSync(packageJsonPath);
-    createOrUpdatePackageJson(packageJsonPath);
-    console.log(
-      packageJsonExists ? "✓ Updated package.json" : "✓ Created package.json"
-    );
-
-    // Install .NET type declarations
-    const shouldInstallTypes = !options.skipTypes;
-    const typesVersion = options.typesVersion ?? "10.0.0";
-
-    if (shouldInstallTypes) {
-      console.log(
-        `Installing .NET type declarations (@tsonic/dotnet-types@${typesVersion})...`
-      );
-      const installResult = installPackage(
-        "@tsonic/dotnet-types",
-        typesVersion
-      );
-      if (!installResult.ok) {
-        return installResult;
-      }
-      console.log("✓ Installed @tsonic/dotnet-types");
-    }
-
-    // Create tsonic.json
-    const config = generateConfig(shouldInstallTypes);
-    writeFileSync(tsonicJsonPath, config, "utf-8");
-    console.log("✓ Created tsonic.json");
-
-    // Create or append to .gitignore
-    if (existsSync(gitignorePath)) {
-      const existing = readFileSync(gitignorePath, "utf-8");
-      if (!existing.includes("generated/")) {
-        writeFileSync(
-          gitignorePath,
-          existing + "\n" + DEFAULT_GITIGNORE,
-          "utf-8"
-        );
-        console.log("✓ Updated .gitignore");
-      }
-    } else {
-      writeFileSync(gitignorePath, DEFAULT_GITIGNORE, "utf-8");
-      console.log("✓ Created .gitignore");
-    }
-
-    // Create src directory and main.ts
-    if (!existsSync(srcDir)) {
-      mkdirSync(srcDir, { recursive: true });
-    }
-    if (!existsSync(mainTsPath)) {
-      writeFileSync(mainTsPath, SAMPLE_MAIN_TS, "utf-8");
-      console.log("✓ Created src/main.ts");
-    }
-
-    // Create README.md
-    if (!existsSync(readmePath)) {
-      writeFileSync(readmePath, SAMPLE_README, "utf-8");
-      console.log("✓ Created README.md");
-    }
-
-    console.log("\n✓ Project initialized successfully!");
-    console.log("\nNext steps:");
-    console.log("  npm run build   # Build executable");
-    console.log("  npm run dev     # Run directly");
-
-    return { ok: true, value: undefined };
-  } catch (error) {
-    return {
-      ok: false,
-      error: `Failed to initialize project: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-};

package/src/commands/run.ts

@@ -1,51 +0,0 @@
-/**
- * tsonic run command - Build and execute
- */
-
-import { spawnSync } from "node:child_process";
-import type { ResolvedConfig, Result } from "../types.js";
-import { buildCommand } from "./build.js";
-
-/**
- * Build and run the executable
- */
-export const runCommand = (
-  config: ResolvedConfig,
-  programArgs: string[] = []
-): Result<{ exitCode: number }, string> => {
-  // Build the executable
-  const buildResult = buildCommand(config);
-  if (!buildResult.ok) {
-    return buildResult;
-  }
-
-  const { outputPath } = buildResult.value;
-
-  if (!config.quiet) {
-    console.log(`\nRunning ${outputPath}...`);
-    console.log("─".repeat(50));
-  }
-
-  // Execute the binary
-  const runResult = spawnSync(outputPath, programArgs, {
-    stdio: "inherit",
-    encoding: "utf-8",
-  });
-
-  if (runResult.error) {
-    return {
-      ok: false,
-      error: `Failed to run executable: ${runResult.error.message}`,
-    };
-  }
-
-  if (!config.quiet) {
-    console.log("─".repeat(50));
-    console.log(`\nProcess exited with code ${runResult.status ?? 0}`);
-  }
-
-  return {
-    ok: true,
-    value: { exitCode: runResult.status ?? 0 },
-  };
-};