@travetto/compiler 7.0.3 → 7.0.4

package/src/state.ts

@@ -1,17 +1,17 @@
-import ts from 'typescript';
+import type { CompilerHost, SourceFile, CompilerOptions, Program, ScriptTarget } from 'typescript';
 
-import { path, ManifestModuleUtil, type ManifestModule, type ManifestRoot, ManifestIndex, ManifestModuleFolderType } from '@travetto/manifest';
-import { TransformerManager } from '@travetto/transformer';
-
-import { TypescriptUtil } from '../support/ts-util.ts';
+import { path, ManifestModuleUtil, type ManifestModule, type ManifestRoot, type ManifestIndex, type ManifestModuleFolderType } from '@travetto/manifest';
+import type { TransformerManager } from '@travetto/transformer';
 
 import { CompilerUtil } from './util.ts';
-import { CompileEmitError, CompileStateEntry } from './types.ts';
-import { CommonUtil } from '../support/util.ts';
+import type { CompileEmitError, CompileStateEntry } from './types.ts';
+import { CommonUtil } from './common.ts';
+import { tsProxy as ts, tsProxyInit } from './ts-proxy.ts';
+
 
 const TYPINGS_FOLDER_KEYS = new Set<ManifestModuleFolderType>(['$index', 'support', 'src', '$package']);
 
-export class CompilerState implements ts.CompilerHost {
+export class CompilerState implements CompilerHost {
 
   static async get(idx: ManifestIndex): Promise<CompilerState> {
     return new CompilerState().init(idx);
@@ -29,15 +29,15 @@ export class CompilerState implements ts.CompilerHost {
   #tscOutputFileToOuptut = new Map<string, string>();
 
   #sourceContents = new Map<string, string | undefined>();
-  #sourceFileObjects = new Map<string, ts.SourceFile>();
+  #sourceFileObjects = new Map<string, SourceFile>();
   #sourceHashes = new Map<string, number>();
 
   #manifestIndex: ManifestIndex;
   #manifest: ManifestRoot;
   #modules: ManifestModule[];
   #transformerManager: TransformerManager;
-  #compilerOptions: ts.CompilerOptions;
-  #program: ts.Program;
+  #compilerOptions: CompilerOptions;
+  #program: Program;
 
   #readFile(sourceFile: string): string | undefined {
     return ts.sys.readFile(this.#sourceToEntry.get(sourceFile)?.sourceFile ?? sourceFile);
@@ -57,44 +57,69 @@ export class CompilerState implements ts.CompilerHost {
     }
   }
 
+  async #initCompilerOptions(): Promise<CompilerOptions> {
+    const tsconfigFile = CommonUtil.resolveWorkspace(this.#manifest, 'tsconfig.json');
+    if (!ts.sys.fileExists(tsconfigFile)) {
+      ts.sys.writeFile(tsconfigFile, JSON.stringify({ extends: '@travetto/compiler/tsconfig.trv.json' }, null, 2));
+    }
+
+    const { options } = ts.parseJsonSourceFileConfigFileContent(
+      ts.readJsonConfigFile(tsconfigFile, ts.sys.readFile),
+      ts.sys,
+      this.#manifest.workspace.path
+    );
+
+    return {
+      ...options,
+      noEmit: false,
+      emitDeclarationOnly: false,
+      allowJs: true,
+      resolveJsonModule: true,
+      sourceRoot: this.#manifest.workspace.path,
+      rootDir: this.#manifest.workspace.path,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      module: ts.ModuleKind.ESNext,
+      outDir: this.#outputPath
+    };
+  }
+
   async init(idx: ManifestIndex): Promise<this> {
     this.#manifestIndex = idx;
     this.#manifest = idx.manifest;
     this.#outputPath = path.resolve(this.#manifest.workspace.path, this.#manifest.build.outputFolder);
     this.#typingsPath = path.resolve(this.#manifest.workspace.path, this.#manifest.build.typesFolder);
 
-    this.#compilerOptions = {
-      ...await TypescriptUtil.getCompilerOptions(this.#manifest),
-      rootDir: this.#manifest.workspace.path,
-      outDir: this.#outputPath
-    };
-
     this.#modules = Object.values(this.#manifest.modules);
 
     // Register all inputs
-    for (const mod of this.#modules) {
-      const base = mod?.files ?? {};
+    for (const module of this.#modules) {
+      const base = module?.files ?? {};
       const files = [
         ...base.bin ?? [],
         ...base.src ?? [],
         ...base.support ?? [],
         ...base.doc ?? [],
         ...base.test ?? [],
+        ...base.$transformer ?? [],
         ...base.$index ?? [],
         ...base.$package ?? []
       ];
       for (const [file, type] of files) {
-        if (CompilerUtil.validFile(type)) {
-          this.registerInput(mod, file);
+        if (ManifestModuleUtil.isSourceType(type)) {
+          this.registerInput(module, file);
         }
       }
     }
-
-    this.#transformerManager = await TransformerManager.create(this.#manifestIndex);
-
     return this;
   }
 
+  async initializeTypescript(): Promise<void> {
+    await tsProxyInit();
+    this.#compilerOptions = await this.#initCompilerOptions();
+    const { TransformerManager } = await import('@travetto/transformer');
+    this.#transformerManager ??= await TransformerManager.create(this.#manifestIndex);
+  }
+
   get manifest(): ManifestRoot {
     return this.#manifest;
   }
@@ -109,13 +134,13 @@ export class CompilerState implements ts.CompilerHost {
 
   getArbitraryInputFile(): string {
     const randomSource = this.#manifestIndex.getWorkspaceModules()
-      .filter(mod => mod.files.src?.length)[0]
+      .filter(module => module.files.src?.length)[0]
       .files.src[0].sourceFile;
 
     return this.getBySource(randomSource)!.sourceFile;
   }
 
-  async createProgram(force = false): Promise<ts.Program> {
+  async createProgram(force = false): Promise<Program> {
     if (force || !this.#program) {
       this.#program = ts.createProgram({ rootNames: this.getAllFiles(), host: this, options: this.#compilerOptions, oldProgram: this.#program });
       this.#transformerManager.init(this.#program.getTypeChecker());
@@ -162,6 +187,11 @@ export class CompilerState implements ts.CompilerHost {
     return this.#sourceToEntry.get(sourceFile);
   }
 
+  isCompilerFile(file: string): boolean {
+    const entry = this.getBySource(file);
+    return (entry?.moduleFile && ManifestModuleUtil.getFileRole(entry.moduleFile) === 'compile') || entry?.module.roles.includes('compile') || false;
+  }
+
   registerInput(module: ManifestModule, moduleFile: string): CompileStateEntry {
     const relativeSource = `${module.sourceFolder || '.'}/${moduleFile}`;
     const relativeOutput = `${module.outputFolder}/${moduleFile}`;
@@ -172,7 +202,7 @@ export class CompilerState implements ts.CompilerHost {
     const tscOutputFile = path.resolve(this.#outputPath, ManifestModuleUtil.withOutputExtension(relativeSource));
     const outputFile = path.resolve(this.#outputPath, ManifestModuleUtil.withOutputExtension(relativeOutput));
 
-    const entry: CompileStateEntry = { sourceFile, outputFile, module, tscOutputFile, import: `${module.name}/${moduleFile}` };
+    const entry: CompileStateEntry = { sourceFile, outputFile, module, tscOutputFile, import: `${module.name}/${moduleFile}`, moduleFile };
 
     this.#outputToEntry.set(outputFile, entry);
     this.#sourceFiles.add(sourceFile);
@@ -199,7 +229,7 @@ export class CompilerState implements ts.CompilerHost {
     if (!contents || (contents.length === 0 && prevHash)) {
       return false; // Ignore empty file
     }
-    const currentHash = CommonUtil.naiveHash(contents);
+    const currentHash = CompilerUtil.naiveHash(contents);
     const changed = prevHash !== currentHash;
     if (changed) {
       this.#sourceHashes.set(sourceFile, currentHash);
@@ -235,7 +265,7 @@ export class CompilerState implements ts.CompilerHost {
   /* Start Compiler Host */
   getCanonicalFileName(file: string): string { return file; }
   getCurrentDirectory(): string { return this.#manifest.workspace.path; }
-  getDefaultLibFileName(options: ts.CompilerOptions): string { return ts.getDefaultLibFileName(options); }
+  getDefaultLibFileName(options: CompilerOptions): string { return ts.getDefaultLibFileName(options); }
   getNewLine(): string { return ts.sys.newLine; }
   useCaseSensitiveFileNames(): boolean { return ts.sys.useCaseSensitiveFileNames; }
   getDefaultLibLocation(): string { return path.dirname(ts.getDefaultLibFilePath(this.#compilerOptions)); }
@@ -275,7 +305,7 @@ export class CompilerState implements ts.CompilerHost {
     return contents;
   }
 
-  getSourceFile(sourceFile: string, language: ts.ScriptTarget): ts.SourceFile {
+  getSourceFile(sourceFile: string, language: ScriptTarget): SourceFile {
     if (!this.#sourceFileObjects.has(sourceFile)) {
       const content = this.readFile(sourceFile)!;
       this.#sourceFileObjects.set(sourceFile, ts.createSourceFile(sourceFile, content ?? '', language));

package/src/ts-proxy.ts

@@ -0,0 +1,11 @@
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+import type ts from 'typescript';
+
+let state: typeof ts | undefined;
+export const tsProxyInit = (): Promise<unknown> => import('typescript').then(module => { state = module.default; });
+
+export const tsProxy = new Proxy({}!, {
+  get(_, prop: string): unknown {
+    return state![prop as keyof typeof ts];
+  }
+}) as typeof ts;

package/src/types.ts

@@ -2,9 +2,41 @@ import type ts from 'typescript';
 
 import type { ChangeEventType, ManifestModule } from '@travetto/manifest';
 
+export type CompilerStateType = 'startup' | 'init' | 'compile-start' | 'compile-end' | 'watch-start' | 'watch-end' | 'reset' | 'closed';
+export type CompilerLogLevel = 'info' | 'debug' | 'warn' | 'error';
+
 export type CompileEmitError = Error | readonly ts.Diagnostic[];
 export type CompileEmitter = (file: string, newProgram?: boolean) => Promise<CompileEmitError | undefined>;
 export type CompileEmitEvent = { file: string, i: number, total: number, error?: CompileEmitError, duration: number };
-export type CompileStateEntry = { sourceFile: string, tscOutputFile: string, outputFile?: string, module: ManifestModule, import: string };
-export type CompilerWatchEvent = { action: ChangeEventType, file: string, entry: CompileStateEntry };
+export type CompileStateEntry = { sourceFile: string, tscOutputFile: string, outputFile?: string, module: ManifestModule, import: string, moduleFile: string };
+export type CompilerWatchEvent = { action: ChangeEventType, file: string, entry: CompileStateEntry, moduleFile: string };
+
+export type CompilerChangeEvent = { file: string, action: ChangeEventType, output: string, module: string, import: string, time: number };
+export type CompilerLogEvent = { level: CompilerLogLevel, message: string, time?: number, args?: unknown[], scope?: string };
+export type CompilerProgressEvent = { idx: number, total: number, message: string, operation: 'compile', complete?: boolean };
+export type CompilerStateEvent = { state: CompilerStateType, extra?: Record<string, unknown> };
+export type FileChangeEvent = { files: { file: string, action: ChangeEventType }[], time: number };
+
+export type CompilerEvent =
+  { type: 'file', payload: FileChangeEvent } |
+  { type: 'change', payload: CompilerChangeEvent } |
+  { type: 'log', payload: CompilerLogEvent } |
+  { type: 'progress', payload: CompilerProgressEvent } |
+  { type: 'state', payload: CompilerStateEvent } |
+  { type: 'all', payload: unknown };
+
+export type CompilerEventType = CompilerEvent['type'];
+export type CompilerEventPayload<V> = (CompilerEvent & { type: V })['payload'];
+
+export type CompilerServerInfo = {
+  path: string;
+  serverProcessId: number;
+  compilerProcessId: number;
+  state: CompilerStateType;
+  watching: boolean;
+  iteration: number;
+  url: string;
+  env?: Record<string, string>;
+};
+
 export class CompilerReset extends Error { }

package/src/util.ts

@@ -1,6 +1,7 @@
-import ts from 'typescript';
+import { ManifestModuleUtil, type ManifestRoot, type Package } from '@travetto/manifest';
 
-import { ManifestModuleFileType, ManifestModuleUtil, ManifestRoot, Package } from '@travetto/manifest';
+import type { CompileEmitError } from './types.ts';
+import { tsProxy as ts } from './ts-proxy.ts';
 
 const nativeCwd = process.cwd();
 
@@ -9,11 +10,6 @@ const nativeCwd = process.cwd();
  */
 export class CompilerUtil {
 
-  /**
-   * Determine if this is a manifest file we care about
-   */
-  static validFile = (type: ManifestModuleFileType): boolean => type === 'ts' || type === 'package-json' || type === 'js' || type === 'typings';
-
   /**
    * Rewrites the package.json to target output file names, and pins versions
    * @param manifest
@@ -47,7 +43,7 @@ export class CompilerUtil {
    * @param filename The name of the file
    * @param diagnostics The diagnostic errors
    */
-  static buildTranspileError(filename: string, diagnostics: Error | readonly ts.Diagnostic[]): Error {
+  static buildTranspileError(filename: string, diagnostics: CompileEmitError): Error {
     if (diagnostics instanceof Error) {
       return diagnostics;
     }
@@ -67,4 +63,18 @@ export class CompilerUtil {
     }
     return new Error(`Transpiling ${filename.replace(nativeCwd, '.')} failed: \n${errors.join('\n')}`);
   }
+
+  /**
+   * Naive hashing
+   */
+  static naiveHash(text: string): number {
+    let hash = 5381;
+
+    for (let i = 0; i < text.length; i++) {
+      // eslint-disable-next-line no-bitwise
+      hash = (hash * 33) ^ text.charCodeAt(i);
+    }
+
+    return Math.abs(hash);
+  }
 }

package/src/watch.ts

@@ -1,14 +1,13 @@
 import fs from 'node:fs/promises';
 import { watch } from 'node:fs';
 
-import { ManifestFileUtil, ManifestModuleUtil, ManifestRoot, ManifestUtil, PackageUtil, path } from '@travetto/manifest';
+import { ManifestFileUtil, ManifestModuleUtil, ManifestUtil, PackageUtil, path } from '@travetto/manifest';
 
 import { CompilerReset, type CompilerWatchEvent, type CompileStateEntry } from './types.ts';
-import { CompilerState } from './state.ts';
-import { CompilerUtil } from './util.ts';
+import type { CompilerState } from './state.ts';
 
-import { AsyncQueue } from '../support/queue.ts';
-import { IpcLogger } from '../support/log.ts';
+import { AsyncQueue } from './queue.ts';
+import { IpcLogger } from './log.ts';
 import { EventUtil } from './event.ts';
 
 const log = new IpcLogger({ level: 'debug' });
@@ -17,7 +16,7 @@ type CompilerWatchEventCandidate = Omit<CompilerWatchEvent, 'entry'> & { entry?:
 
 export class CompilerWatcher {
   #state: CompilerState;
-  #cleanup: Partial<Record<'tool' | 'workspace' | 'canary', () => (void | Promise<void>)>> = {};
+  #cleanup: Partial<Record<'tool' | 'workspace' | 'canary' | 'git', () => (void | Promise<void>)>> = {};
   #watchCanary: string = '.trv/canary.id';
   #lastWorkspaceModified = Date.now();
   #watchCanaryFrequency = 5;
@@ -28,7 +27,7 @@ export class CompilerWatcher {
     this.#state = state;
     this.#root = state.manifest.workspace.path;
     this.#queue = new AsyncQueue(signal);
-    signal.addEventListener('abort', () => Object.values(this.#cleanup).forEach(fn => fn()));
+    signal.addEventListener('abort', () => Object.values(this.#cleanup).forEach(fn => fn?.()));
   }
 
   async #getWatchIgnores(): Promise<string[]> {
@@ -38,7 +37,7 @@ export class CompilerWatcher {
       '**/node_modules',
       '.*/**/node_modules'
     ];
-    const ignores = new Set(['node_modules', '.git']);
+    const ignores = new Set(['node_modules', '.git', this.#state.resolveOutputFile('.')]);
     for (const item of patterns) {
       if (item.includes('*')) {
         for await (const sub of fs.glob(item, { cwd: this.#root })) {
@@ -59,15 +58,17 @@ export class CompilerWatcher {
 
   #toCandidateEvent({ action, file }: Pick<CompilerWatchEvent, 'action' | 'file'>): CompilerWatchEventCandidate {
     let entry = this.#state.getBySource(file);
-    const mod = entry?.module ?? this.#state.manifestIndex.findModuleForArbitraryFile(file);
-    if (mod && action === 'create' && !entry) {
-      const modRoot = mod.sourceFolder || this.#root;
-      const moduleFile = file.includes(`${modRoot}/`) ? file.split(`${modRoot}/`)[1] : file;
-      entry = this.#state.registerInput(mod, moduleFile);
+    const module = entry?.module ?? this.#state.manifestIndex.findModuleForArbitraryFile(file);
+
+    if (module && action === 'create' && !entry) {
+      const moduleRoot = module.sourceFolder || this.#root;
+      const moduleFile = file.includes(`${moduleRoot}/`) ? file.split(`${moduleRoot}/`)[1] : file;
+      entry = this.#state.registerInput(module, moduleFile);
     } else if (action === 'delete' && entry) {
       this.#state.removeSource(entry.sourceFile); // Ensure we remove it
     }
-    return { entry, file: entry?.sourceFile ?? file, action };
+
+    return { entry, file: entry?.sourceFile ?? file, action, moduleFile: entry?.moduleFile! };
   }
 
   #isValidFile(file: string): boolean {
@@ -88,65 +89,24 @@ export class CompilerWatcher {
       const relativeFile = event.file.replace(`${this.#root}/`, '');
       log.debug(`Skipping update, as contents unchanged ${relativeFile}`);
       return false;
-    } else if (!CompilerUtil.validFile(ManifestModuleUtil.getFileType(event.file))) {
+    } else if (!ManifestModuleUtil.isSourceType(event.file)) {
       return false;
     }
     return true;
   }
 
-  #getManifestUpdateEventsByParents(events: CompilerWatchEvent[]): Map<string, CompilerWatchEvent[]> {
-    const eventsByMod = new Map<string, CompilerWatchEvent[]>();
-    for (const event of events) {
-      if (event.action === 'update') {
-        continue;
-      }
-
-      const mod = event.entry.module;
-      const moduleSet = new Set(this.#state.manifestIndex.getDependentModules(mod.name, 'parents').map(indexedMod => indexedMod.name));
-      moduleSet.add(this.#state.manifest.workspace.name);
-      for (const moduleName of moduleSet) {
-        if (!eventsByMod.has(moduleName)) {
-          eventsByMod.set(moduleName, []);
-        }
-        eventsByMod.get(moduleName)!.push(event);
-      }
-    }
-    return eventsByMod;
-  }
-
-  #updateManifestForEvent({ action, file, entry }: CompilerWatchEvent, manifest: ManifestRoot): void {
-    if (action === 'update') {
-      return;
-    }
-
-    const moduleName = entry.module.name;
-    const moduleRoot = entry.module.sourceFolder || this.#root;
-    const relativeFile = file.includes(moduleRoot) ? file.split(`${moduleRoot}/`)[1] : file;
-    const folderKey = ManifestModuleUtil.getFolderKey(relativeFile);
-    const fileType = ManifestModuleUtil.getFileType(relativeFile);
-    const roleType = ManifestModuleUtil.getFileRole(relativeFile)!;
-
-    const manifestModuleFiles = manifest.modules[moduleName].files[folderKey] ??= [];
-    const idx = manifestModuleFiles.findIndex(indexedFile => indexedFile[0] === relativeFile);
-    const wrappedIdx = idx < 0 ? manifestModuleFiles.length : idx;
-
-    switch (action) {
-      case 'create': manifestModuleFiles[wrappedIdx] = [relativeFile, fileType, Date.now(), roleType]; break;
-      case 'delete': idx >= 0 && manifestModuleFiles.splice(idx, 1); break;
-    }
-  }
-
-  async #reconcileManifestUpdates(compilerEvents: CompilerWatchEvent[]): Promise<void> {
-    for (const [mod, events] of this.#getManifestUpdateEventsByParents(compilerEvents).entries()) {
-      const moduleRoot = this.#state.manifestIndex.getManifestModule(mod)!.sourceFolder;
-      const moduleContext = ManifestUtil.getModuleContext(this.#state.manifest, moduleRoot);
-      const manifestLocation = ManifestUtil.getManifestLocation(moduleContext, mod);
-      const moduleManifest = ManifestUtil.readManifestSync(manifestLocation);
+  async #updateManifestWithEvents(compilerEvents: CompilerWatchEvent[]): Promise<void> {
+    const eventsByModule = this.#state.manifestIndex.groupByLineage(
+      compilerEvents.map(event => ({ item: event, module: event.entry!.module.name }))
+        .filter(x => x.item.action !== 'update')
+    );
 
-      log.debug('Updating manifest', { module: mod, events: events.length });
-      for (const event of events) {
-        this.#updateManifestForEvent(event, moduleManifest);
+    for (const [moduleName, events] of eventsByModule.entries()) {
+      const moduleManifest = this.#state.manifestIndex.resolveDependentManifest(moduleName);
+      for (const { moduleFile, action, entry } of events) {
+        ManifestUtil.updateManifest(moduleManifest, entry.module.name, moduleFile, action);
       }
+      log.debug('Updating manifest', { module: moduleName, events: events.length });
       await ManifestUtil.writeManifest(moduleManifest);
     }
 
@@ -176,11 +136,18 @@ export class CompilerWatcher {
         }
 
         // One event per file set
-        const filesChanged = events.map(e => ({ file: path.toPosix(e.path), action: e.type })).filter(e => this.#isValidFile(e.file));
+        const filesChanged = events
+          .map(event => ({ file: path.toPosix(event.path), action: event.type }))
+          .filter(event => this.#isValidFile(event.file));
+
         if (filesChanged.length) {
           EventUtil.sendEvent('file', { time: Date.now(), files: filesChanged });
         }
 
+        if (filesChanged.some(item => this.#state.isCompilerFile(item.file))) {
+          throw new CompilerReset('Compiler has changed, restarting');
+        }
+
         const items = filesChanged
           .map(event => this.#toCandidateEvent(event))
           .filter(event => this.#isValidEvent(event));
@@ -190,10 +157,10 @@ export class CompilerWatcher {
         }
 
         try {
-          await this.#reconcileManifestUpdates(items);
+          await this.#updateManifestWithEvents(items);
         } catch (manifestError) {
           log.info('Restarting due to manifest rebuild failure', manifestError);
-          throw new CompilerReset(`Manifest rebuild failure: ${manifestError}`);
+          throw new CompilerReset(`Manifest rebuild failure: ${manifestError} `);
         }
 
         for (const item of items) {
@@ -203,7 +170,7 @@ export class CompilerWatcher {
         if (out instanceof Error && out.message.includes('Events were dropped by the FSEvents client.')) {
           out = new CompilerReset('FSEvents failure, requires restart');
         }
-        return this.#queue.throw(out instanceof Error ? out : new Error(`${out}`));
+        return this.#queue.throw(out instanceof Error ? out : new Error(`${out} `));
       }
     }, { ignore });
 
@@ -212,10 +179,9 @@ export class CompilerWatcher {
 
   async #listenToolFolder(): Promise<void> {
     const build = this.#state.manifest.build;
-    const toolRootFolder = path.dirname(path.resolve(this.#root, build.compilerFolder));
-    const toolFolders = new Set([
-      toolRootFolder, build.compilerFolder, build.typesFolder, build.outputFolder
-    ].map(folder => path.resolve(this.#root, folder)));
+    const toolRootFolder = path.dirname(path.resolve(this.#root, build.outputFolder));
+    const toolFolders = new Set([toolRootFolder, build.typesFolder, build.outputFolder]
+      .map(folder => path.resolve(this.#root, folder)));
 
     log.debug('Tooling Folders', [...toolFolders].map(folder => folder.replace(`${this.#root}/`, '')));
 
@@ -258,11 +224,27 @@ export class CompilerWatcher {
     this.#cleanup.canary = (): void => clearInterval(canaryId);
   }
 
+  async #listenGitChanges(): Promise<void> {
+    const gitFolder = path.resolve(this.#root, '.git');
+    if (!await fs.stat(gitFolder).catch(() => false)) { return; }
+    log.debug('Starting git canary');
+    const listener = watch(gitFolder, { encoding: 'utf8' }, async (event, file) => {
+      if (!file) {
+        return;
+      }
+      if (file === 'HEAD') {
+        this.#queue.throw(new CompilerReset('Git branch change detected'));
+      }
+    });
+    this.#cleanup.git = (): void => listener.close();
+  }
+
   [Symbol.asyncIterator](): AsyncIterator<CompilerWatchEvent> {
     if (!this.#cleanup.workspace) {
       this.#listenWorkspace();
       this.#listenToolFolder();
       this.#listenCanary();
+      this.#listenGitChanges();
     }
     return this.#queue[Symbol.asyncIterator]();
   }

package/support/invoke.ts

@@ -0,0 +1,96 @@
+// @trv-no-transform
+import { getManifestContext, ManifestUtil } from '@travetto/manifest';
+
+import { Log } from '../src/log.ts';
+import { CompilerManager } from '../src/server/manager.ts';
+import { CompilerClient } from '../src/server/client.ts';
+import { CommonUtil } from '../src/common.ts';
+import { EventUtil } from '../src/event.ts';
+
+const HELP = `
+npx trvc [command]
+
+Available Commands:
+ * start|watch                - Run the compiler in watch mode
+ * stop                       - Stop the compiler if running
+ * restart                    - Restart the compiler in watch mode
+ * build                      - Ensure the project is built and upto date
+ * clean                      - Clean out the output and compiler caches
+ * info                       - Retrieve the compiler information, if running
+ * event <log|progress|state> - Watch events in realtime as newline delimited JSON
+ * exec <file> [...args]      - Allow for compiling and executing an entrypoint file
+ * manifest --prod [output]   - Generate the project manifest
+`;
+
+/**
+ * Invoke the compiler
+ */
+export async function invoke(operation?: string, args: string[] = []): Promise<unknown> {
+  if (operation === undefined) {
+    [operation, ...args] = process.argv.slice(2);
+  }
+  const ctx = getManifestContext();
+  const client = new CompilerClient(ctx, Log.scoped('client'));
+
+  Log.initLevel('error');
+  Log.root = ctx.workspace.path;
+
+  switch (operation) {
+    case undefined:
+    case 'help': console.log(HELP); break;
+    case 'start':
+    case 'watch': return CompilerManager.compile(ctx, client, { watch: true });
+    case 'build': return CompilerManager.compile(ctx, client, { watch: false });
+    case 'restart': return CompilerManager.compile(ctx, client, { watch: true, forceRestart: true });
+    case 'info': {
+      const info = await client.info();
+      return CommonUtil.writeStdout(2, info);
+    }
+    case 'event': {
+      if (!EventUtil.isComplilerEventType(args[0])) {
+        throw new Error(`Unknown event type: ${args[0]}`);
+      }
+      for await (const event of client.fetchEvents(args[0])) {
+        await CommonUtil.writeStdout(0, event);
+      }
+      break;
+    }
+    case 'manifest:production':
+    case 'manifest': {
+      let manifest = await ManifestUtil.buildManifest(ctx);
+      if (operation === 'manifest:production') {
+        manifest = await ManifestUtil.createProductionManifest(manifest);
+      }
+      if (args[0]) {
+        await ManifestUtil.writeManifestToFile(args[0], manifest);
+        console.log(`Wrote manifest to ${args[0]}`);
+      } else {
+        await CommonUtil.writeStdout(2, manifest);
+      }
+      break;
+    }
+    case 'clean': {
+      await client.clean(true);
+      console.log(`Clean triggered ${ctx.workspace.path}`);
+      break;
+    }
+    case 'stop': {
+      if (await client.stop()) {
+        console.log(`Stopped server ${ctx.workspace.path}: ${client.url}`);
+      } else {
+        console.log(`Server not running ${ctx.workspace.path}: ${client.url}`);
+      }
+      break;
+    }
+    case 'exec': {
+      await CompilerManager.compileIfNecessary(ctx, client);
+      Log.initLevel('none');
+      process.env.TRV_MANIFEST = CommonUtil.resolveWorkspace(ctx, ctx.build.outputFolder, 'node_modules', ctx.main.name); // Setup for running
+      const importTarget = CommonUtil.resolveWorkspace(ctx, ctx.build.outputFolder, 'node_modules', args[0]);
+      process.argv = [process.argv0, importTarget, ...args.slice(1)];
+      // Return function to run import on a module
+      return import(importTarget);
+    }
+    default: console.error(`\nUnknown trvc operation: ${operation}\n${HELP}`);
+  }
+}