almostnode 0.1.0

package/src/shims/os.ts

@@ -0,0 +1,195 @@
+/**
+ * Node.js os module shim
+ * Provides operating system utilities
+ */
+
+export function hostname(): string {
+  return 'localhost';
+}
+
+export function platform(): string {
+  return 'linux';
+}
+
+export function arch(): string {
+  return 'x64';
+}
+
+export function type(): string {
+  return 'Linux';
+}
+
+export function release(): string {
+  return '5.10.0';
+}
+
+export function version(): string {
+  return '#1 SMP';
+}
+
+export function machine(): string {
+  return 'x86_64';
+}
+
+export function tmpdir(): string {
+  return '/tmp';
+}
+
+export function homedir(): string {
+  return '/home/user';
+}
+
+export function cpus(): Array<{
+  model: string;
+  speed: number;
+  times: { user: number; nice: number; sys: number; idle: number; irq: number };
+}> {
+  const cpu = {
+    model: 'Virtual CPU',
+    speed: 2400,
+    times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 },
+  };
+  return [cpu, cpu]; // Simulate 2 CPUs
+}
+
+export function totalmem(): number {
+  return 4 * 1024 * 1024 * 1024; // 4GB
+}
+
+export function freemem(): number {
+  return 2 * 1024 * 1024 * 1024; // 2GB
+}
+
+export function uptime(): number {
+  return Math.floor(performance.now() / 1000);
+}
+
+export function loadavg(): [number, number, number] {
+  return [0.5, 0.5, 0.5];
+}
+
+export function networkInterfaces(): Record<
+  string,
+  Array<{
+    address: string;
+    netmask: string;
+    family: string;
+    mac: string;
+    internal: boolean;
+    cidr: string;
+  }>
+> {
+  return {
+    lo: [
+      {
+        address: '127.0.0.1',
+        netmask: '255.0.0.0',
+        family: 'IPv4',
+        mac: '00:00:00:00:00:00',
+        internal: true,
+        cidr: '127.0.0.1/8',
+      },
+    ],
+  };
+}
+
+export function userInfo(): {
+  username: string;
+  uid: number;
+  gid: number;
+  shell: string;
+  homedir: string;
+} {
+  return {
+    username: 'user',
+    uid: 1000,
+    gid: 1000,
+    shell: '/bin/bash',
+    homedir: '/home/user',
+  };
+}
+
+export function endianness(): 'BE' | 'LE' {
+  return 'LE';
+}
+
+export function getPriority(pid?: number): number {
+  return 0;
+}
+
+export function setPriority(pid: number | number, priority?: number): void {
+  // No-op
+}
+
+export const EOL = '\n';
+
+export const constants = {
+  signals: {
+    SIGHUP: 1,
+    SIGINT: 2,
+    SIGQUIT: 3,
+    SIGILL: 4,
+    SIGTRAP: 5,
+    SIGABRT: 6,
+    SIGBUS: 7,
+    SIGFPE: 8,
+    SIGKILL: 9,
+    SIGUSR1: 10,
+    SIGSEGV: 11,
+    SIGUSR2: 12,
+    SIGPIPE: 13,
+    SIGALRM: 14,
+    SIGTERM: 15,
+    SIGCHLD: 17,
+    SIGCONT: 18,
+    SIGSTOP: 19,
+    SIGTSTP: 20,
+    SIGTTIN: 21,
+    SIGTTOU: 22,
+    SIGURG: 23,
+    SIGXCPU: 24,
+    SIGXFSZ: 25,
+    SIGVTALRM: 26,
+    SIGPROF: 27,
+    SIGWINCH: 28,
+    SIGIO: 29,
+    SIGPWR: 30,
+    SIGSYS: 31,
+  },
+  errno: {},
+  priority: {
+    PRIORITY_LOW: 19,
+    PRIORITY_BELOW_NORMAL: 10,
+    PRIORITY_NORMAL: 0,
+    PRIORITY_ABOVE_NORMAL: -7,
+    PRIORITY_HIGH: -14,
+    PRIORITY_HIGHEST: -20,
+  },
+};
+
+export const devNull = '/dev/null';
+
+export default {
+  hostname,
+  platform,
+  arch,
+  type,
+  release,
+  version,
+  machine,
+  tmpdir,
+  homedir,
+  cpus,
+  totalmem,
+  freemem,
+  uptime,
+  loadavg,
+  networkInterfaces,
+  userInfo,
+  endianness,
+  getPriority,
+  setPriority,
+  EOL,
+  constants,
+  devNull,
+};

package/src/shims/path.ts

@@ -0,0 +1,199 @@
+/**
+ * Node.js path module shim
+ * Implements POSIX path operations for virtual file system
+ */
+
+export const sep = '/';
+export const delimiter = ':';
+
+export function normalize(path: string): string {
+  if (!path) return '.';
+
+  const isAbsolute = path.startsWith('/');
+  const parts = path.split('/').filter(Boolean);
+  const resolved: string[] = [];
+
+  for (const part of parts) {
+    if (part === '..') {
+      if (resolved.length > 0 && resolved[resolved.length - 1] !== '..') {
+        resolved.pop();
+      } else if (!isAbsolute) {
+        resolved.push('..');
+      }
+    } else if (part !== '.') {
+      resolved.push(part);
+    }
+  }
+
+  let result = resolved.join('/');
+  if (isAbsolute) {
+    result = '/' + result;
+  }
+
+  return result || '.';
+}
+
+// Track join calls to debug infinite recursion
+let joinCallCount = 0;
+
+export function join(...paths: string[]): string {
+  if (paths.length === 0) return '.';
+  const result = normalize(paths.filter(Boolean).join('/'));
+  // Debug: Log _generated path joins
+  if (paths.some(p => p && p.includes('_generated'))) {
+    joinCallCount++;
+    if (joinCallCount <= 20) {
+      console.log(`[path.join] (${paths.join(', ')}) -> ${result}`);
+    }
+  }
+  return result;
+}
+
+export function resolve(...paths: string[]): string {
+  let resolvedPath = '';
+
+  for (let i = paths.length - 1; i >= 0 && !resolvedPath.startsWith('/'); i--) {
+    const path = paths[i];
+    if (!path) continue;
+    resolvedPath = path + (resolvedPath ? '/' + resolvedPath : '');
+  }
+
+  if (!resolvedPath.startsWith('/')) {
+    resolvedPath = '/' + resolvedPath;
+  }
+
+  return normalize(resolvedPath);
+}
+
+export function isAbsolute(path: string): boolean {
+  return path.startsWith('/');
+}
+
+export function dirname(path: string): string {
+  if (!path) return '.';
+
+  const normalized = normalize(path);
+  const lastSlash = normalized.lastIndexOf('/');
+
+  if (lastSlash === -1) return '.';
+  if (lastSlash === 0) return '/';
+
+  return normalized.slice(0, lastSlash);
+}
+
+export function basename(path: string, ext?: string): string {
+  if (!path) return '';
+
+  const normalized = normalize(path);
+  let base = normalized.slice(normalized.lastIndexOf('/') + 1);
+
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, -ext.length);
+  }
+
+  return base;
+}
+
+export function extname(path: string): string {
+  const base = basename(path);
+  const dotIndex = base.lastIndexOf('.');
+
+  if (dotIndex <= 0) return '';
+
+  return base.slice(dotIndex);
+}
+
+export function relative(from: string, to: string): string {
+  from = resolve(from);
+  to = resolve(to);
+
+  if (from === to) return '';
+
+  const fromParts = from.split('/').filter(Boolean);
+  const toParts = to.split('/').filter(Boolean);
+
+  let commonLength = 0;
+  for (let i = 0; i < Math.min(fromParts.length, toParts.length); i++) {
+    if (fromParts[i] !== toParts[i]) break;
+    commonLength++;
+  }
+
+  const upCount = fromParts.length - commonLength;
+  const remainingPath = toParts.slice(commonLength);
+
+  const result = [...Array(upCount).fill('..'), ...remainingPath];
+
+  return result.join('/') || '.';
+}
+
+export function parse(path: string): {
+  root: string;
+  dir: string;
+  base: string;
+  ext: string;
+  name: string;
+} {
+  const normalized = normalize(path);
+  const isAbs = isAbsolute(normalized);
+  const dir = dirname(normalized);
+  const base = basename(normalized);
+  const ext = extname(normalized);
+  const name = base.slice(0, base.length - ext.length);
+
+  return {
+    root: isAbs ? '/' : '',
+    dir,
+    base,
+    ext,
+    name,
+  };
+}
+
+export function format(pathObject: {
+  root?: string;
+  dir?: string;
+  base?: string;
+  ext?: string;
+  name?: string;
+}): string {
+  const dir = pathObject.dir || pathObject.root || '';
+  const base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');
+
+  if (!dir) return base;
+  if (dir === pathObject.root) return dir + base;
+
+  return dir + '/' + base;
+}
+
+// POSIX interface (we only support POSIX)
+export const posix = {
+  sep,
+  delimiter,
+  normalize,
+  join,
+  resolve,
+  isAbsolute,
+  dirname,
+  basename,
+  extname,
+  relative,
+  parse,
+  format,
+};
+
+// Default export for CommonJS compatibility
+export default {
+  sep,
+  delimiter,
+  normalize,
+  join,
+  resolve,
+  isAbsolute,
+  dirname,
+  basename,
+  extname,
+  relative,
+  parse,
+  format,
+  posix,
+};

package/src/shims/perf_hooks.ts

@@ -0,0 +1,92 @@
+/**
+ * perf_hooks shim - Performance measurement APIs
+ * Wraps browser Performance API
+ */
+
+export const performance = globalThis.performance || {
+  now: () => Date.now(),
+  timeOrigin: Date.now(),
+  mark: () => {},
+  measure: () => {},
+  getEntries: () => [],
+  getEntriesByName: () => [],
+  getEntriesByType: () => [],
+  clearMarks: () => {},
+  clearMeasures: () => {},
+  clearResourceTimings: () => {},
+};
+
+export class PerformanceObserver {
+  private callback: (list: PerformanceObserverEntryList) => void;
+  private entryTypes: string[] = [];
+
+  constructor(callback: (list: PerformanceObserverEntryList) => void) {
+    this.callback = callback;
+  }
+
+  observe(options: { entryTypes?: string[]; type?: string }): void {
+    this.entryTypes = options.entryTypes || (options.type ? [options.type] : []);
+  }
+
+  disconnect(): void {
+    this.entryTypes = [];
+  }
+
+  takeRecords(): PerformanceEntry[] {
+    return [];
+  }
+
+  static supportedEntryTypes = ['mark', 'measure', 'resource', 'navigation'];
+}
+
+export interface PerformanceObserverEntryList {
+  getEntries(): PerformanceEntry[];
+  getEntriesByName(name: string, type?: string): PerformanceEntry[];
+  getEntriesByType(type: string): PerformanceEntry[];
+}
+
+export interface PerformanceEntry {
+  name: string;
+  entryType: string;
+  startTime: number;
+  duration: number;
+}
+
+// Histogram stub
+export class Histogram {
+  min = 0;
+  max = 0;
+  mean = 0;
+  stddev = 0;
+  percentiles = new Map<number, number>();
+  exceeds = 0;
+
+  reset(): void {
+    this.min = 0;
+    this.max = 0;
+    this.mean = 0;
+    this.stddev = 0;
+    this.percentiles.clear();
+    this.exceeds = 0;
+  }
+
+  percentile(percentile: number): number {
+    return this.percentiles.get(percentile) || 0;
+  }
+}
+
+export function createHistogram(): Histogram {
+  return new Histogram();
+}
+
+export function monitorEventLoopDelay(options?: { resolution?: number }): Histogram {
+  const histogram = new Histogram();
+  return histogram;
+}
+
+export default {
+  performance,
+  PerformanceObserver,
+  createHistogram,
+  monitorEventLoopDelay,
+};