@vibe-lang/runtime 0.2.5

package/src/debug/ts-import-tracker.ts

@@ -0,0 +1,151 @@
+/**
+ * TS Import Tracker
+ * Tracks imported TypeScript functions for debugging
+ */
+
+import type { SourceLocation } from '../errors';
+
+// Imported TS function info
+export interface TsImportInfo {
+  // The name used in Vibe code
+  vibeName: string;
+  // The .ts file path
+  tsFile: string;
+  // The original function name in the TS file
+  tsFunctionName: string;
+  // The .vibe file that imported it
+  importedBy: string;
+  // Line in .vibe file where import statement is
+  importLine: number;
+  // Whether we've resolved the entry point line in the TS file
+  entryLine?: number;
+}
+
+// Registry of imported TS functions
+const tsImports = new Map<string, TsImportInfo>();
+
+// Temporary breakpoints set for stepping into TS
+const tempBreakpoints = new Map<string, string>(); // tsFile:line -> breakpointId
+
+/**
+ * Register an imported TS function
+ */
+export function registerTsImport(
+  vibeName: string,
+  tsFile: string,
+  tsFunctionName: string,
+  importedBy: string,
+  importLine: number
+): void {
+  const key = `${importedBy}:${vibeName}`;
+  tsImports.set(key, {
+    vibeName,
+    tsFile,
+    tsFunctionName,
+    importedBy,
+    importLine,
+  });
+}
+
+/**
+ * Get info about an imported TS function
+ */
+export function getTsImportInfo(vibeFile: string, functionName: string): TsImportInfo | undefined {
+  const key = `${vibeFile}:${functionName}`;
+  return tsImports.get(key);
+}
+
+/**
+ * Check if a function call targets an imported TS function
+ */
+export function isTsImportCall(vibeFile: string, functionName: string): boolean {
+  const key = `${vibeFile}:${functionName}`;
+  return tsImports.has(key);
+}
+
+/**
+ * Set the entry line for a TS function (once resolved by Bun inspector)
+ */
+export function setTsImportEntryLine(
+  vibeFile: string,
+  functionName: string,
+  entryLine: number
+): void {
+  const key = `${vibeFile}:${functionName}`;
+  const info = tsImports.get(key);
+  if (info) {
+    info.entryLine = entryLine;
+  }
+}
+
+/**
+ * Register a temporary breakpoint for stepping into TS
+ */
+export function registerTempBreakpoint(
+  tsFile: string,
+  line: number,
+  breakpointId: string
+): void {
+  const key = `${tsFile}:${line}`;
+  tempBreakpoints.set(key, breakpointId);
+}
+
+/**
+ * Get and remove a temporary breakpoint
+ */
+export function popTempBreakpoint(tsFile: string, line: number): string | undefined {
+  const key = `${tsFile}:${line}`;
+  const id = tempBreakpoints.get(key);
+  if (id) {
+    tempBreakpoints.delete(key);
+  }
+  return id;
+}
+
+/**
+ * Clear all temporary breakpoints
+ */
+export function clearTempBreakpoints(): Map<string, string> {
+  const all = new Map(tempBreakpoints);
+  tempBreakpoints.clear();
+  return all;
+}
+
+/**
+ * Get all registered TS imports
+ */
+export function getAllTsImports(): TsImportInfo[] {
+  return Array.from(tsImports.values());
+}
+
+/**
+ * Get TS imports for a specific Vibe file
+ */
+export function getTsImportsForFile(vibeFile: string): TsImportInfo[] {
+  return Array.from(tsImports.values()).filter(info => info.importedBy === vibeFile);
+}
+
+/**
+ * Clear all TS import registrations (for testing)
+ */
+export function clearTsImports(): void {
+  tsImports.clear();
+  tempBreakpoints.clear();
+}
+
+/**
+ * Build a unique identifier for a TS function entry point
+ * Used to match breakpoint hits
+ */
+export function buildTsEntryPointId(tsFile: string, functionName: string): string {
+  return `ts:${tsFile}:${functionName}`;
+}
+
+/**
+ * Parse a TS entry point ID
+ */
+export function parseTsEntryPointId(id: string): { tsFile: string; functionName: string } | null {
+  const match = id.match(/^ts:(.+):([^:]+)$/);
+  if (!match) return null;
+  return { tsFile: match[1], functionName: match[2] };
+}

package/src/debug/ts-source-map.ts

@@ -0,0 +1,171 @@
+/**
+ * TS Block Source Mapping
+ * Maps TypeScript block code to locations within .vibe files
+ */
+
+import type { SourceLocation } from '../errors';
+
+// Mapping from generated TS code to original .vibe location
+export interface TsBlockMapping {
+  // The .vibe file containing the ts block
+  vibeFile: string;
+  // Line in .vibe file where ts block starts
+  vibeStartLine: number;
+  // Column in .vibe file where ts block starts
+  vibeStartColumn: number;
+  // The ts block body (for matching)
+  tsBody: string;
+  // Parameters passed to the ts block
+  params: string[];
+  // Generated script ID (assigned by Bun inspector)
+  scriptId?: string;
+}
+
+// Registry of all TS block mappings
+const tsBlockMappings = new Map<string, TsBlockMapping>();
+
+// Counter for generating unique IDs
+let mappingIdCounter = 0;
+
+/**
+ * Register a TS block for debugging
+ * Returns a unique ID for this TS block
+ */
+export function registerTsBlock(
+  vibeFile: string,
+  vibeLocation: SourceLocation,
+  tsBody: string,
+  params: string[]
+): string {
+  const id = `ts_block_${++mappingIdCounter}`;
+
+  tsBlockMappings.set(id, {
+    vibeFile,
+    vibeStartLine: vibeLocation.line,
+    vibeStartColumn: vibeLocation.column,
+    tsBody,
+    params,
+  });
+
+  return id;
+}
+
+/**
+ * Get mapping for a TS block by ID
+ */
+export function getTsBlockMapping(id: string): TsBlockMapping | undefined {
+  return tsBlockMappings.get(id);
+}
+
+/**
+ * Find TS block mapping by script ID (assigned by Bun inspector)
+ */
+export function findMappingByScriptId(scriptId: string): TsBlockMapping | undefined {
+  for (const mapping of tsBlockMappings.values()) {
+    if (mapping.scriptId === scriptId) {
+      return mapping;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Associate a script ID with a TS block mapping
+ */
+export function setScriptId(mappingId: string, scriptId: string): void {
+  const mapping = tsBlockMappings.get(mappingId);
+  if (mapping) {
+    mapping.scriptId = scriptId;
+  }
+}
+
+/**
+ * Convert a location within generated TS code to the original .vibe location
+ */
+export function mapTsLocationToVibe(
+  mapping: TsBlockMapping,
+  tsLine: number,
+  tsColumn: number
+): SourceLocation {
+  // The first line of the TS block body corresponds to vibeStartLine
+  // We add the line offset (tsLine - 1 since TS lines are 0-based in inspector)
+  // Note: We subtract 1 for the 'use strict' line we prepend
+  const lineOffset = Math.max(0, tsLine - 1);
+
+  return {
+    file: mapping.vibeFile,
+    line: mapping.vibeStartLine + lineOffset,
+    column: lineOffset === 0 ? mapping.vibeStartColumn + tsColumn : tsColumn,
+  };
+}
+
+/**
+ * Convert a .vibe location to a location within a TS block
+ */
+export function mapVibeLocationToTs(
+  mapping: TsBlockMapping,
+  vibeLine: number,
+  vibeColumn: number
+): { line: number; column: number } | null {
+  // Check if this location is within the TS block
+  const tsBlockLines = mapping.tsBody.split('\n').length;
+  const lineOffset = vibeLine - mapping.vibeStartLine;
+
+  if (lineOffset < 0 || lineOffset >= tsBlockLines) {
+    return null; // Location is outside this TS block
+  }
+
+  // Add 1 for the 'use strict' line we prepend
+  return {
+    line: lineOffset + 1,
+    column: lineOffset === 0 ? Math.max(0, vibeColumn - mapping.vibeStartColumn) : vibeColumn,
+  };
+}
+
+/**
+ * Check if a .vibe location is within a TS block
+ */
+export function isLocationInTsBlock(
+  vibeFile: string,
+  vibeLine: number
+): TsBlockMapping | null {
+  for (const mapping of tsBlockMappings.values()) {
+    if (mapping.vibeFile !== vibeFile) continue;
+
+    const tsBlockLines = mapping.tsBody.split('\n').length;
+    const endLine = mapping.vibeStartLine + tsBlockLines - 1;
+
+    if (vibeLine >= mapping.vibeStartLine && vibeLine <= endLine) {
+      return mapping;
+    }
+  }
+  return null;
+}
+
+/**
+ * Get all TS block mappings for a file
+ */
+export function getMappingsForFile(vibeFile: string): TsBlockMapping[] {
+  const mappings: TsBlockMapping[] = [];
+  for (const mapping of tsBlockMappings.values()) {
+    if (mapping.vibeFile === vibeFile) {
+      mappings.push(mapping);
+    }
+  }
+  return mappings;
+}
+
+/**
+ * Clear all mappings (useful for testing)
+ */
+export function clearTsBlockMappings(): void {
+  tsBlockMappings.clear();
+  mappingIdCounter = 0;
+}
+
+/**
+ * Get all registered mappings (for debugging)
+ */
+export function getAllMappings(): Map<string, TsBlockMapping> {
+  return new Map(tsBlockMappings);
+}

package/src/errors/index.ts

@@ -0,0 +1,124 @@
+// Source location for error reporting
+export interface SourceLocation {
+  line: number;
+  column: number;
+  file?: string;
+}
+
+export interface SourceSpan {
+  start: SourceLocation;
+  end: SourceLocation;
+}
+
+// Base error class for all Vibe errors
+export class VibeError extends Error {
+  constructor(
+    message: string,
+    public location?: SourceLocation,
+    public source?: string
+  ) {
+    super(message);
+    this.name = 'VibeError';
+  }
+
+  format(): string {
+    if (!this.location) {
+      return this.message;
+    }
+
+    const loc = `[${this.location.file ?? 'vibe'}:${this.location.line}:${this.location.column}]`;
+    let result = `${loc} ${this.message}`;
+
+    // Add source context if available
+    if (this.source) {
+      const lines = this.source.split('\n');
+      const line = lines[this.location.line - 1];
+      if (line) {
+        result += `\n\n  ${this.location.line} | ${line}`;
+        result += `\n    ${' '.repeat(String(this.location.line).length)} | ${' '.repeat(this.location.column - 1)}^`;
+      }
+    }
+
+    return result;
+  }
+}
+
+// Lexer errors
+export class LexerError extends VibeError {
+  constructor(message: string, location?: SourceLocation, source?: string) {
+    super(message, location, source);
+    this.name = 'LexerError';
+  }
+}
+
+// Parser errors
+export class ParserError extends VibeError {
+  constructor(
+    message: string,
+    public tokenValue?: string,
+    location?: SourceLocation,
+    source?: string
+  ) {
+    super(message, location, source);
+    this.name = 'ParserError';
+  }
+}
+
+// Runtime errors
+export class RuntimeError extends VibeError {
+  constructor(
+    message: string,
+    location?: SourceLocation,
+    source?: string,
+    public context?: Record<string, unknown>
+  ) {
+    super(message, location, source);
+    this.name = 'RuntimeError';
+  }
+}
+
+// Type errors
+export class TypeError extends VibeError {
+  constructor(
+    message: string,
+    public expected?: string,
+    public received?: string,
+    location?: SourceLocation,
+    source?: string
+  ) {
+    super(message, location, source);
+    this.name = 'TypeError';
+  }
+}
+
+// Reference errors (undefined variables)
+export class ReferenceError extends VibeError {
+  constructor(
+    public variableName: string,
+    location?: SourceLocation,
+    source?: string
+  ) {
+    super(`Undefined variable '${variableName}'`, location, source);
+    this.name = 'ReferenceError';
+  }
+}
+
+// Assignment errors (const reassignment)
+export class AssignmentError extends VibeError {
+  constructor(
+    public variableName: string,
+    location?: SourceLocation,
+    source?: string
+  ) {
+    super(`Cannot reassign constant '${variableName}'`, location, source);
+    this.name = 'AssignmentError';
+  }
+}
+
+// Semantic errors (type checking, scope validation)
+export class SemanticError extends VibeError {
+  constructor(message: string, location?: SourceLocation, source?: string) {
+    super(message, location, source);
+    this.name = 'SemanticError';
+  }
+}