arc-lang 0.5.9 → 0.6.1

package/dist/errors.d.ts

@@ -40,13 +40,25 @@ export interface ArcError {
 }
 export declare function levenshtein(a: string, b: string): number;
 export declare function findClosestMatch(name: string, candidates: string[], maxDistance?: number): string | null;
-export declare function formatError(error: ArcError, useColor?: boolean): string;
+export declare function formatError(error: ArcError, useColor?: boolean, filePath?: string): string;
 export declare function undefinedVariableError(name: string, candidates: string[], loc?: AST.Loc, source?: string): ArcError;
 export declare function parseError(message: string, loc?: AST.Loc, source?: string, suggestion?: string): ArcError;
 export declare function typeError(message: string, loc?: AST.Loc, source?: string): ArcError;
 export declare function runtimeError(code: ErrorCode, message: string, loc?: AST.Loc, source?: string, suggestion?: string): ArcError;
 export declare function importError(message: string, loc?: AST.Loc, source?: string): ArcError;
 export declare function securityError(code: ErrorCode, message: string): ArcError;
-export declare function prettyPrintError(err: Error, source?: string, useColor?: boolean): string;
+export declare function prettyPrintError(err: Error, source?: string, useColor?: boolean, filePath?: string): string;
+export declare class ArcRuntimeError extends Error {
+    loc?: AST.Loc;
+    arcCode: ErrorCode;
+    arcCategory: ErrorCategory;
+    suggestion?: string;
+    constructor(message: string, options?: {
+        code?: ErrorCode;
+        category?: ErrorCategory;
+        loc?: AST.Loc;
+        suggestion?: string;
+    });
+}
 export declare function setPrettyErrors(enabled: boolean): void;
 export declare function isPrettyErrorsEnabled(): boolean;

package/dist/errors.js

@@ -84,11 +84,18 @@ export function findClosestMatch(name, candidates, maxDistance = 3) {
     return best;
 }
 // Format a rich error message with source snippet
-export function formatError(error, useColor = true) {
+export function formatError(error, useColor = true, filePath) {
     const c = useColor ? COLORS : { red: "", yellow: "", cyan: "", gray: "", bold: "", reset: "", underline: "" };
     const lines = [];
     // Header: category[code]: message
     lines.push(`${c.red}${c.bold}${error.category}[${error.code}]${c.reset}: ${c.bold}${error.message}${c.reset}`);
+    // Location line
+    if (filePath && error.loc) {
+        lines.push(`${c.cyan}  --> ${filePath}:${error.loc.line}:${error.loc.col}${c.reset}`);
+    }
+    else if (error.loc) {
+        lines.push(`${c.cyan}  --> line ${error.loc.line}:${error.loc.col}${c.reset}`);
+    }
     // Source snippet with error pointer
     if (error.source && error.loc) {
         const sourceLines = error.source.split("\n");
@@ -188,10 +195,54 @@ export function securityError(code, message) {
     };
 }
 // Pretty-print an error that was caught during execution
-export function prettyPrintError(err, source, useColor = true) {
+export function prettyPrintError(err, source, useColor = true, filePath) {
+    // Check for ParseError (has loc property)
+    if ("loc" in err && err.loc && err.message.startsWith("Parse error")) {
+        const loc = err.loc;
+        let cleanMsg = err.message.replace(/^Parse error at line \d+, col \d+: /, "");
+        // Make token names more human-friendly
+        cleanMsg = cleanMsg
+            .replace(/\bRBrace\b/g, "'}'")
+            .replace(/\bLBrace\b/g, "'{'")
+            .replace(/\bRParen\b/g, "')'")
+            .replace(/\bLParen\b/g, "'('")
+            .replace(/\bRBracket\b/g, "']'")
+            .replace(/\bLBracket\b/g, "'['")
+            .replace(/\bEOF ''/g, "end of file")
+            .replace(/^Expected /, "Expected ");
+        const rawMsg = err.message.replace(/^Parse error at line \d+, col \d+: /, "");
+        let suggestion;
+        if (rawMsg.includes("Expected RBrace"))
+            suggestion = "Add a closing '}' to match the opening brace.";
+        else if (rawMsg.includes("Expected RParen"))
+            suggestion = "Add a closing ')' to match the opening parenthesis.";
+        else if (rawMsg.includes("Expected RBracket"))
+            suggestion = "Add a closing ']' to match the opening bracket.";
+        return formatError({
+            code: ErrorCode.UNEXPECTED_TOKEN,
+            category: "ParseError",
+            message: cleanMsg,
+            loc,
+            source,
+            suggestion,
+        }, useColor, filePath);
+    }
+    // If it's already a structured ArcRuntimeError, use its fields directly
+    if (err instanceof ArcRuntimeError) {
+        const cleanMsg = err.message.replace(/ at line \d+(?:, col \d+)?$/, "");
+        return formatError({
+            code: err.arcCode,
+            category: err.arcCategory,
+            message: cleanMsg,
+            loc: err.loc,
+            source,
+            suggestion: err.suggestion,
+        }, useColor, filePath);
+    }
     // Try to extract location from error message
     const locMatch = err.message.match(/at line (\d+)(?:, col (\d+))?/);
     const loc = locMatch ? { line: parseInt(locMatch[1]), col: parseInt(locMatch[2] || "1") } : undefined;
+    const cleanMsg = err.message.replace(/ at line \d+(?:, col \d+)?$/, "");
     // Detect error category
     let category = "RuntimeError";
     let code = ErrorCode.UNDEFINED_VARIABLE;
@@ -199,13 +250,16 @@ export function prettyPrintError(err, source, useColor = true) {
     if (err.message.includes("Parse error")) {
         category = "ParseError";
         code = ErrorCode.UNEXPECTED_TOKEN;
+        // Extract suggestion for parse errors
+        if (err.message.includes("Expected RBrace"))
+            suggestion = "Missing closing brace '}'";
+        else if (err.message.includes("Expected RParen"))
+            suggestion = "Missing closing parenthesis ')'";
+        else if (err.message.includes("Expected RBracket"))
+            suggestion = "Missing closing bracket ']'";
     }
     else if (err.message.includes("Undefined variable")) {
         code = ErrorCode.UNDEFINED_VARIABLE;
-        const nameMatch = err.message.match(/Undefined variable: (\w+)/);
-        if (nameMatch) {
-            suggestion = `Check that '${nameMatch[1]}' is defined before use`;
-        }
     }
     else if (err.message.includes("Cannot reassign immutable")) {
         code = ErrorCode.IMMUTABLE_REASSIGN;
@@ -213,12 +267,39 @@ export function prettyPrintError(err, source, useColor = true) {
     }
     else if (err.message.includes("Not callable")) {
         code = ErrorCode.NOT_CALLABLE;
+        suggestion = "Only functions can be called. Check that the value is a function.";
+    }
+    else if (err.message.includes("Division by zero")) {
+        code = ErrorCode.DIVISION_BY_ZERO;
+        suggestion = "Check that the divisor is not zero before dividing.";
+    }
+    else if (err.message.includes("Module not found")) {
+        category = "ImportError";
+        code = ErrorCode.MODULE_NOT_FOUND;
     }
     else if (err.message.includes("SecurityError") || err.name === "SecurityError") {
         category = "SecurityError";
         code = ErrorCode.EXECUTION_LIMIT;
     }
-    return formatError({ code, category, message: err.message, loc, source, suggestion }, useColor);
+    else if (err.message.includes("Cannot access property")) {
+        code = ErrorCode.PROPERTY_ACCESS;
+    }
+    return formatError({ code, category, message: cleanMsg, loc, source, suggestion }, useColor, filePath);
+}
+// Custom error class that carries structured location info
+export class ArcRuntimeError extends Error {
+    loc;
+    arcCode;
+    arcCategory;
+    suggestion;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = "ArcRuntimeError";
+        this.arcCode = options.code ?? ErrorCode.UNDEFINED_VARIABLE;
+        this.arcCategory = options.category ?? "RuntimeError";
+        this.loc = options.loc;
+        this.suggestion = options.suggestion;
+    }
 }
 let prettyErrorsEnabled = true;
 export function setPrettyErrors(enabled) {

package/dist/index.js

@@ -13,8 +13,8 @@ import { generateJS } from "./codegen-js.js";
 import { generateWAT } from "./codegen.js";
 import { format } from "./formatter.js";
 import { lint, formatDiagnostic } from "./linter.js";
-import { printVersion } from "./version.js";
-import { setPrettyErrors } from "./errors.js";
+import { printVersion, ARC_VERSION } from "./version.js";
+import { prettyPrintError, setPrettyErrors } from "./errors.js";
 import { build, test as buildTest, newProject } from "./build.js";
 import { pkgInit, pkgAdd, pkgRemove, pkgList, pkgInstall } from "./package-manager.js";
 const args = process.argv.slice(2);
@@ -101,21 +101,32 @@ else if (command === "pkg") {
         process.exit(1);
     }
 }
-else if (!command || !file) {
-    console.log("Usage:");
-    console.log("  npx tsx src/index.ts run <file.arc>   - Execute an Arc file");
-    console.log("  npx tsx src/index.ts parse <file.arc>  - Print the AST");
-    console.log("  npx tsx src/index.ts ir <file.arc>     - Print the IR");
-    console.log("  npx tsx src/index.ts opt <file.arc>    - Print optimized IR");
-    console.log("  npx tsx src/index.ts compile <file.arc> - Compile to JS (or --target=wat)");
-    console.log("  npx tsx src/index.ts check <file.arc>  - Run semantic analysis");
-    console.log("  npx tsx src/index.ts fmt <file.arc>    - Format source code");
-    console.log("  npx tsx src/index.ts lint <file.arc>   - Lint source code");
-    console.log("  npx tsx src/index.ts repl              - Start interactive REPL");
-    console.log("  npx tsx src/index.ts fuzz [--iterations=N] - Fuzz test the language");
-    console.log("  npx tsx src/index.ts bench             - Run performance benchmarks");
-    console.log("  npx tsx src/index.ts bench --tokens    - Run token efficiency comparison");
-    process.exit(1);
+else if (command === "help" || command === "--help" || command === "-h" || !command || !file) {
+    console.log(`Arc ${ARC_VERSION} — A programming language designed by AI agents, for AI agents.\n`);
+    console.log("Usage: arc <command> [options]\n");
+    console.log("Commands:");
+    console.log("  run <file.arc>          Execute an Arc file");
+    console.log("  parse <file.arc>        Print the AST");
+    console.log("  ir <file.arc>           Print the IR");
+    console.log("  opt <file.arc>          Print optimized IR");
+    console.log("  compile <file.arc>      Compile to JS (or --target=wat)");
+    console.log("  check <file.arc>        Run semantic analysis");
+    console.log("  fmt <file.arc>          Format source code (--write to overwrite)");
+    console.log("  lint <file.arc>         Lint source code");
+    console.log("  repl                    Start interactive REPL");
+    console.log("  build                   Build the current project");
+    console.log("  test                    Run project tests");
+    console.log("  new <name>              Create a new project");
+    console.log("  pkg <sub>               Package manager (init|add|remove|list|install)");
+    console.log("  version                 Print version info");
+    console.log("\nOptions:");
+    console.log("  --version, -v           Print version");
+    console.log("  --help, -h              Show this help");
+    console.log("  --no-pretty-errors      Disable pretty error formatting");
+    if (!command || (command !== "help" && command !== "--help" && command !== "-h"))
+        process.exit(1);
+    else
+        process.exit(0);
 }
 else {
     const filePath = resolve(file);
@@ -210,7 +221,12 @@ else {
         }
     }
     catch (e) {
-        console.error(e.message);
+        if (e instanceof Error) {
+            console.error(prettyPrintError(e, source, true, filePath));
+        }
+        else {
+            console.error(e.message ?? String(e));
+        }
         process.exit(1);
     }
 }

package/dist/interpreter.d.ts

@@ -22,6 +22,7 @@ declare class Env {
     private _depth;
     constructor(parent?: Env | undefined);
     get(name: string): Value;
+    allNames(): string[];
     getEntry(name: string): {
         value: Value;
         mutable: boolean;