Refactor architecture

package.json

@@ -240,7 +240,7 @@
     "compile": "npm run check-types && node esbuild.mjs --production",
     "check": "npm test && npm run eslint-check && npm run compile",
     "check-types": "tsc --noEmit",
-    "test": "node --test -r ts-node/register src/features.test.ts",
+    "test": "node --test -r ts-node/register src/contracts.test.ts src/find_executable.test.ts",
     "watch": "npm-run-all -p watch:*",
     "watch:esbuild": "node esbuild.mjs --watch",
     "watch:tsc": "tsc --noEmit --watch --project tsconfig.json",

src/compile_commands.ts → src/commands/compile.ts

@@ -2,8 +2,15 @@
 // Registers commands accessible via Command Palette and keybindings.
 
 import * as vscode from "vscode";
-import * as path from "path";
-import { getCompiler } from "./compile";
+import * as path from "node:path";
+import type { CompileResult, SimplicityHLCompiler } from "../compiler";
+import type { CompileOptions } from "../compiler/args";
+import {
+  COMMAND_IDS,
+  CONFIGURATION_SECTION,
+  LANGUAGE_IDS,
+  SETTINGS,
+} from "../contracts";
 
 function showCompilationFailed(): void {
   vscode.window.showErrorMessage(
@@ -20,14 +27,17 @@ async function getSimplicityHLDocument(): Promise<vscode.TextDocument | undefine
   }
 
   const document = editor.document;
-  if (document.languageId !== "simplicityhl") {
+  if (document.languageId !== LANGUAGE_IDS.source) {
     vscode.window.showWarningMessage("Current file is not a SimplicityHL file (.simf)");
     return undefined;
   }
 
   // Auto-save before compile if enabled
-  const config = vscode.workspace.getConfiguration("simplicityhl");
-  const autoSave = config.get<boolean>("build.autoSaveBeforeCompile", true);
+  const config = vscode.workspace.getConfiguration(CONFIGURATION_SECTION);
+  const autoSave = config.get<boolean>(
+    SETTINGS.autoSaveBeforeCompile.key,
+    SETTINGS.autoSaveBeforeCompile.default,
+  );
   if (autoSave && document.isDirty) {
     const saved = await document.save();
     if (!saved) {
@@ -41,17 +51,24 @@ async function getSimplicityHLDocument(): Promise<vscode.TextDocument | undefine
   return document;
 }
 
+async function compileActiveDocument(
+  compiler: () => SimplicityHLCompiler,
+  options: CompileOptions = {},
+): Promise<CompileResult | undefined> {
+  const document = await getSimplicityHLDocument();
+  return document && compiler().compileFile(document.uri.fsPath, options);
+}
+
 // Register all compile-related commands
-export function registerCompileCommands(context: vscode.ExtensionContext): void {
-  // Basic compile - compiles the current .simf file
+export function registerCompileCommands(
+  context: vscode.ExtensionContext,
+  compiler: () => SimplicityHLCompiler,
+): void {
   const compileFileCommand = vscode.commands.registerCommand(
-    "simplicityhl.compileFile",
+    COMMAND_IDS.compileFile,
     async () => {
-      const document = await getSimplicityHLDocument();
-      if (!document) return;
-
-      const compiler = getCompiler();
-      const result = await compiler.compileFile(document.uri.fsPath);
+      const result = await compileActiveDocument(compiler);
+      if (!result) return;
 
       if (result.success) {
         // Offer to copy output to clipboard
@@ -71,15 +88,11 @@ export function registerCompileCommands(context: vscode.ExtensionContext): void
     }
   );
 
-  // Compile with debug symbols - includes debug info in output
   const compileDebugCommand = vscode.commands.registerCommand(
-    "simplicityhl.compileFileDebug",
+    COMMAND_IDS.compileFileDebug,
     async () => {
-      const document = await getSimplicityHLDocument();
-      if (!document) return;
-
-      const compiler = getCompiler();
-      const result = await compiler.compileFile(document.uri.fsPath, { debug: true });
+      const result = await compileActiveDocument(compiler, { debug: true });
+      if (!result) return;
 
       if (result.success) {
         vscode.window.showInformationMessage("Compiled with debug symbols!");
@@ -89,9 +102,8 @@ export function registerCompileCommands(context: vscode.ExtensionContext): void
     }
   );
 
-  // Compile with witness - satisfies the program with witness data
   const compileWithWitnessCommand = vscode.commands.registerCommand(
-    "simplicityhl.compileWithWitness",
+    COMMAND_IDS.compileWithWitness,
     async () => {
       const document = await getSimplicityHLDocument();
       if (!document) return;
@@ -125,8 +137,7 @@ export function registerCompileCommands(context: vscode.ExtensionContext): void
         return;
       }
 
-      const compiler = getCompiler();
-      const result = await compiler.compileFile(simfPath, { witnessFile });
+      const result = await compiler().compileFile(simfPath, { witnessFile });
 
       if (result.success) {
         const action = await vscode.window.showInformationMessage(
@@ -149,15 +160,11 @@ export function registerCompileCommands(context: vscode.ExtensionContext): void
     }
   );
 
-  // Compile to JSON - outputs result in JSON format in a new editor
   const compileJsonCommand = vscode.commands.registerCommand(
-    "simplicityhl.compileJson",
+    COMMAND_IDS.compileJson,
     async () => {
-      const document = await getSimplicityHLDocument();
-      if (!document) return;
-
-      const compiler = getCompiler();
-      const result = await compiler.compileFile(document.uri.fsPath, { json: true });
+      const result = await compileActiveDocument(compiler, { json: true });
+      if (!result) return;
 
       if (result.success && result.program) {
         // Show JSON output in a new untitled document
@@ -184,6 +191,6 @@ export function registerCompileCommands(context: vscode.ExtensionContext): void
     compileFileCommand,
     compileDebugCommand,
     compileWithWitnessCommand,
-    compileJsonCommand
+    compileJsonCommand,
   );
 }

src/compiler/args.ts

@@ -0,0 +1,56 @@
+import type { ExperimentalFeatures, TaskCommand } from "../contracts";
+
+export interface CompileOptions {
+  debug?: boolean;
+  witnessFile?: string;
+  json?: boolean;
+}
+
+export function compilerFeatureArguments(
+  features: ExperimentalFeatures,
+): string[] {
+  const args: string[] = [];
+  if (features.imports) {
+    args.push("-Z", "imports");
+  }
+  if (features.enums) {
+    args.push("-Z", "enums");
+  }
+  return args;
+}
+
+export function compilerArguments(
+  file: string,
+  features: ExperimentalFeatures,
+  options: CompileOptions = {},
+): string[] {
+  const args = [file, ...compilerFeatureArguments(features)];
+  if (options.witnessFile) {
+    args.push("-w", options.witnessFile);
+  }
+  if (options.debug) {
+    args.push("--debug");
+  }
+  if (options.json) {
+    args.push("--json");
+  }
+  return args;
+}
+
+export function taskCompilerArguments(
+  command: TaskCommand,
+  file: string,
+  witnessFile: string | undefined,
+  features: ExperimentalFeatures,
+): string[] {
+  switch (command) {
+    case "compile":
+      return compilerArguments(file, features);
+    case "compile-debug":
+      return compilerArguments(file, features, { debug: true });
+    case "compile-with-witness":
+      return compilerArguments(file, features, {
+        witnessFile: witnessFile || "${file/.simf/.wit/}",
+      });
+  }
+}