@newt-dev/compiler 0.1.0

package/dist/src/ast.d.ts

@@ -0,0 +1,220 @@
+export interface SourceLocation {
+    line: number;
+    column: number;
+}
+export interface BaseNode {
+    type: string;
+    loc: SourceLocation;
+}
+export interface Program extends BaseNode {
+    type: "Program";
+    body: TopLevelNode[];
+}
+export type TopLevelNode = BotDecl | Handler | TimerDecl;
+export type BotDeclKind = "name" | "prefix" | "token";
+export interface BotDecl extends BaseNode {
+    type: "BotDecl";
+    kind: BotDeclKind;
+    value: StringLiteral;
+    fromEnv: boolean;
+}
+export type Handler = ReadyHandler | CommandHandler | MessageContainsHandler | JoinHandler | LeaveHandler | ReactionAddHandler;
+export interface ReadyHandler extends BaseNode {
+    type: "ReadyHandler";
+    body: Statement[];
+}
+export interface CommandHandler extends BaseNode {
+    type: "CommandHandler";
+    command: string;
+    body: Statement[];
+}
+export interface MessageContainsHandler extends BaseNode {
+    type: "MessageContainsHandler";
+    needle: StringLiteral;
+    body: Statement[];
+}
+export interface JoinHandler extends BaseNode {
+    type: "JoinHandler";
+    body: Statement[];
+}
+export interface LeaveHandler extends BaseNode {
+    type: "LeaveHandler";
+    body: Statement[];
+}
+export interface ReactionAddHandler extends BaseNode {
+    type: "ReactionAddHandler";
+    emoji: StringLiteral;
+    body: Statement[];
+}
+export type TimerDecl = EveryTimerDecl | DailyTimerDecl;
+export interface EveryTimerDecl extends BaseNode {
+    type: "EveryTimerDecl";
+    amount: NumberLiteral;
+    unit: TimeUnit;
+    body: Statement[];
+}
+export interface DailyTimerDecl extends BaseNode {
+    type: "DailyTimerDecl";
+    time: StringLiteral;
+    body: Statement[];
+}
+export type TimeUnit = "second" | "seconds" | "minute" | "minutes" | "hour" | "hours" | "day" | "days";
+export type Statement = ReplyStatement | SayStatement | SayEmbedStatement | LetDecl | StoreStatement | IfStatement | ForEachStatement | RequireRoleStatement | GiveRoleStatement | RemoveRoleStatement | MuteStatement | KickStatement | BanStatement | PinStatement | DeleteKeyStatement | WaitStatement | TryCatchStatement | ExpressionStatement;
+export interface ReplyStatement extends BaseNode {
+    type: "ReplyStatement";
+    message: Expression;
+}
+export interface SayStatement extends BaseNode {
+    type: "SayStatement";
+    message: Expression;
+    channel?: StringLiteral;
+}
+export interface SayEmbedStatement extends BaseNode {
+    type: "SayEmbedStatement";
+    embed: EmbedBlock;
+}
+export interface EmbedBlock extends BaseNode {
+    type: "EmbedBlock";
+    title?: StringLiteral;
+    description?: StringLiteral;
+    color?: ColorLiteral;
+    fields: EmbedField[];
+}
+export interface EmbedField extends BaseNode {
+    type: "EmbedField";
+    name: StringLiteral;
+    value: StringLiteral;
+}
+export interface LetDecl extends BaseNode {
+    type: "LetDecl";
+    name: string;
+    value: Expression;
+}
+export interface StoreStatement extends BaseNode {
+    type: "StoreStatement";
+    namespace: Expression;
+    key: string;
+    value: Expression;
+}
+export interface IfStatement extends BaseNode {
+    type: "IfStatement";
+    condition: Expression;
+    consequent: Statement[];
+    alternate: Statement[];
+}
+export interface ForEachStatement extends BaseNode {
+    type: "ForEachStatement";
+    itemName: string;
+    iterable: Expression;
+    body: Statement[];
+}
+export interface RequireRoleStatement extends BaseNode {
+    type: "RequireRoleStatement";
+    role: StringLiteral;
+}
+export interface GiveRoleStatement extends BaseNode {
+    type: "GiveRoleStatement";
+    subject: Expression;
+    role: StringLiteral;
+}
+export interface RemoveRoleStatement extends BaseNode {
+    type: "RemoveRoleStatement";
+    subject: Expression;
+    role: StringLiteral;
+}
+export interface MuteStatement extends BaseNode {
+    type: "MuteStatement";
+    subject: Expression;
+    duration?: DurationLiteral;
+}
+export interface KickStatement extends BaseNode {
+    type: "KickStatement";
+    subject: Expression;
+}
+export interface BanStatement extends BaseNode {
+    type: "BanStatement";
+    subject: Expression;
+}
+export interface PinStatement extends BaseNode {
+    type: "PinStatement";
+    target: Expression;
+}
+export interface DeleteKeyStatement extends BaseNode {
+    type: "DeleteKeyStatement";
+    namespace: Expression;
+    key: string;
+}
+export interface WaitStatement extends BaseNode {
+    type: "WaitStatement";
+    duration: DurationLiteral;
+}
+export interface TryCatchStatement extends BaseNode {
+    type: "TryCatchStatement";
+    body: Statement[];
+    errorHandler: Statement[];
+}
+export interface ExpressionStatement extends BaseNode {
+    type: "ExpressionStatement";
+    expression: Expression;
+}
+export type Expression = StringLiteral | NumberLiteral | BooleanLiteral | ColorLiteral | IdentifierExpr | MemberExpr | ArgsIndexExpr | LoadExpr | FetchExpr | BinaryExpr | UnaryExpr | CallExpr;
+export interface StringLiteral extends BaseNode {
+    type: "StringLiteral";
+    value: string;
+    interpolated: boolean;
+}
+export interface NumberLiteral extends BaseNode {
+    type: "NumberLiteral";
+    value: number;
+}
+export interface BooleanLiteral extends BaseNode {
+    type: "BooleanLiteral";
+    value: boolean;
+}
+export interface ColorLiteral extends BaseNode {
+    type: "ColorLiteral";
+    value: string;
+}
+export interface IdentifierExpr extends BaseNode {
+    type: "IdentifierExpr";
+    name: string;
+}
+export interface MemberExpr extends BaseNode {
+    type: "MemberExpr";
+    path: string[];
+}
+export interface ArgsIndexExpr extends BaseNode {
+    type: "ArgsIndexExpr";
+    index: number;
+}
+export interface LoadExpr extends BaseNode {
+    type: "LoadExpr";
+    namespace: Expression;
+    key: string;
+    fallback?: Expression;
+}
+export interface FetchExpr extends BaseNode {
+    type: "FetchExpr";
+    url: Expression;
+}
+export interface BinaryExpr extends BaseNode {
+    type: "BinaryExpr";
+    operator: string;
+    left: Expression;
+    right: Expression;
+}
+export interface UnaryExpr extends BaseNode {
+    type: "UnaryExpr";
+    operator: string;
+    argument: Expression;
+}
+export interface CallExpr extends BaseNode {
+    type: "CallExpr";
+    callee: string;
+    args: Expression[];
+}
+export interface DurationLiteral extends BaseNode {
+    type: "DurationLiteral";
+    amount: NumberLiteral;
+    unit: TimeUnit;
+}

package/dist/src/ast.js

@@ -0,0 +1 @@
+export {};

package/dist/src/codegen.d.ts

@@ -0,0 +1,6 @@
+import type { Program } from "./ast.js";
+export interface GeneratedProject {
+    botJs: string;
+    packageJson: string;
+}
+export declare function generate(program: Program): GeneratedProject;

package/dist/src/codegen.js

@@ -0,0 +1,266 @@
+export function generate(program) {
+    const botName = getBotValue(program, "name") ?? "NewtBot";
+    const prefix = getBotValue(program, "prefix") ?? "!";
+    const tokenDecl = program.body.find((node) => node.type === "BotDecl" && node.kind === "token");
+    const tokenExpr = tokenDecl?.fromEnv ? `process.env.${tokenDecl.value.value}` : JSON.stringify(tokenDecl?.value.value ?? "");
+    const handlers = program.body
+        .filter((node) => node.type.endsWith("Handler") || node.type.endsWith("TimerDecl"))
+        .map((node) => emitTopLevel(node, prefix))
+        .join("\n\n");
+    const botJs = `import { Client, EmbedBuilder, GatewayIntentBits, Partials } from "discord.js";
+import Database from "better-sqlite3";
+import axios from "axios";
+
+const client = new Client({
+  intents: [
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMessages,
+    GatewayIntentBits.GuildMembers,
+    GatewayIntentBits.MessageContent,
+    GatewayIntentBits.GuildMessageReactions
+  ],
+  partials: [Partials.Message, Partials.Channel, Partials.Reaction]
+});
+
+const db = new Database("newt-store.sqlite");
+db.exec("CREATE TABLE IF NOT EXISTS store (namespace TEXT NOT NULL, key TEXT NOT NULL, value TEXT, PRIMARY KEY(namespace, key))");
+const botName = ${JSON.stringify(botName)};
+const prefix = ${JSON.stringify(prefix)};
+
+function saveValue(namespace, key, value) {
+  db.prepare("INSERT OR REPLACE INTO store(namespace, key, value) VALUES (?, ?, ?)").run(String(namespace), String(key), JSON.stringify(value));
+}
+
+function loadValue(namespace, key, fallback = undefined) {
+  const row = db.prepare("SELECT value FROM store WHERE namespace = ? AND key = ?").get(String(namespace), String(key));
+  return row ? JSON.parse(row.value) : fallback;
+}
+
+function findChannel(guild, name) {
+  return guild?.channels?.cache?.find((channel) => channel.name === name);
+}
+
+function findRole(guild, name) {
+  return guild?.roles?.cache?.find((role) => role.name === name);
+}
+
+${handlers}
+
+client.login(${tokenExpr});
+`;
+    return {
+        botJs,
+        packageJson: JSON.stringify({
+            type: "module",
+            scripts: { start: "node bot.js" },
+            dependencies: {
+                "axios": "^1.7.0",
+                "better-sqlite3": "^11.0.0",
+                "discord.js": "^14.15.0"
+            }
+        }, null, 2)
+    };
+}
+function getBotValue(program, kind) {
+    return program.body.find((node) => node.type === "BotDecl" && node.kind === kind)?.value.value;
+}
+function emitTopLevel(node, prefix) {
+    switch (node.type) {
+        case "ReadyHandler":
+            return `client.once("ready", async () => {
+  for (const guild of client.guilds.cache.values()) {
+    const server = guild;
+${emitStatements(node.body, "    ", "guild")}
+  }
+});`;
+        case "CommandHandler":
+            return `client.on("messageCreate", async (message) => {
+  if (message.author.bot) return;
+  if (!message.content.startsWith(prefix + ${JSON.stringify(node.command)})) return;
+  const args = message.content.slice((prefix + ${JSON.stringify(node.command)}).length).trim().split(/\\s+/).filter(Boolean);
+  const user = message.author;
+  const channel = message.channel;
+  const server = message.guild;
+  const target = message.mentions.members.first();
+${emitStatements(node.body, "  ", "message")}
+});`;
+        case "MessageContainsHandler":
+            return `client.on("messageCreate", async (message) => {
+  if (message.author.bot) return;
+  if (!message.content.includes(${emitExpression(node.needle)})) return;
+  const user = message.author;
+  const channel = message.channel;
+  const server = message.guild;
+${emitStatements(node.body, "  ", "message")}
+});`;
+        case "JoinHandler":
+            return `client.on("guildMemberAdd", async (member) => {
+  const user = member.user;
+  const server = member.guild;
+  const channel = findChannel(server, "general");
+${emitStatements(node.body, "  ", "member")}
+});`;
+        case "LeaveHandler":
+            return `client.on("guildMemberRemove", async (member) => {
+  const user = member.user;
+  const server = member.guild;
+${emitStatements(node.body, "  ", "member")}
+});`;
+        case "ReactionAddHandler":
+            return `client.on("messageReactionAdd", async (reaction, user) => {
+  if (reaction.emoji.name !== ${emitExpression(node.emoji)}) return;
+  const message = reaction.message;
+  const channel = message.channel;
+  const server = message.guild;
+${emitStatements(node.body, "  ", "message")}
+});`;
+        case "EveryTimerDecl":
+            return `setInterval(async () => {\n${emitStatements(node.body, "  ", "message")}\n}, ${durationMs(node.amount.value, node.unit)});`;
+        case "DailyTimerDecl":
+            return `setInterval(async () => {
+  const now = new Date();
+  const hhmm = now.toTimeString().slice(0, 5);
+  if (hhmm !== ${emitExpression(node.time)}) return;
+${emitStatements(node.body, "  ", "message")}
+}, 60000);`;
+        default:
+            return "";
+    }
+}
+function emitStatements(statements, indent, triggerName) {
+    return statements.map((statement) => emitStatement(statement, indent, triggerName)).join("\n");
+}
+function emitStatement(statement, indent, triggerName) {
+    switch (statement.type) {
+        case "ReplyStatement":
+            return `${indent}await ${triggerName}.reply(${emitExpression(statement.message)});`;
+        case "SayStatement": {
+            if (statement.channel) {
+                return `${indent}await findChannel(${triggerName === "guild" ? "server" : `server ?? ${triggerName}.guild`}, ${emitExpression(statement.channel)})?.send(${emitExpression(statement.message)});`;
+            }
+            return `${indent}await (${triggerName}.channel ?? channel)?.send(${emitExpression(statement.message)});`;
+        }
+        case "SayEmbedStatement":
+            if (triggerName === "member") {
+                return `${indent}await findChannel(server, "general")?.send({ embeds: [${emitEmbed(statement.embed)}] });`;
+            }
+            return `${indent}await (${triggerName}.channel ?? channel)?.send({ embeds: [${emitEmbed(statement.embed)}] });`;
+        case "LetDecl":
+            return `${indent}const ${statement.name} = ${emitExpression(statement.value)};`;
+        case "StoreStatement":
+            return `${indent}saveValue(${emitExpression(statement.namespace)}, ${JSON.stringify(statement.key)}, ${emitExpression(statement.value)});`;
+        case "IfStatement":
+            return `${indent}if (${emitExpression(statement.condition)}) {\n${emitStatements(statement.consequent, `${indent}  `, triggerName)}\n${indent}}${statement.alternate.length ? ` else {\n${emitStatements(statement.alternate, `${indent}  `, triggerName)}\n${indent}}` : ""}`;
+        case "ForEachStatement":
+            return `${indent}for (const ${statement.itemName} of (server?.members?.cache?.values?.() ?? [])) {\n${emitStatements(statement.body, `${indent}  `, triggerName)}\n${indent}}`;
+        case "RequireRoleStatement":
+            return `${indent}if (!${triggerName}.member?.roles?.cache?.some((role) => role.name === ${emitExpression(statement.role)})) return;`;
+        case "GiveRoleStatement":
+            if (triggerName === "member") {
+                return `${indent}await ${triggerName}.roles?.add(findRole(server, ${emitExpression(statement.role)}));`;
+            }
+            return `${indent}await (${emitExpression(statement.subject)}?.roles ?? ${triggerName}.member?.roles)?.add(findRole(server ?? ${triggerName}.guild, ${emitExpression(statement.role)}));`;
+        case "RemoveRoleStatement":
+            return `${indent}await (${emitExpression(statement.subject)}?.roles ?? ${triggerName}.member?.roles)?.remove(findRole(server ?? ${triggerName}.guild, ${emitExpression(statement.role)}));`;
+        case "MuteStatement":
+            return `${indent}await ${emitExpression(statement.subject)}?.timeout?.(${statement.duration ? durationMs(statement.duration.amount.value, statement.duration.unit) : 600000});`;
+        case "KickStatement":
+            return `${indent}await ${emitExpression(statement.subject)}?.kick?.();`;
+        case "BanStatement":
+            return `${indent}await ${emitExpression(statement.subject)}?.ban?.();`;
+        case "TryCatchStatement":
+            return `${indent}try {\n${emitStatements(statement.body, `${indent}  `, triggerName)}\n${indent}} catch (error) {\n${emitStatements(statement.errorHandler, `${indent}  `, triggerName)}\n${indent}}`;
+        case "WaitStatement":
+            return `${indent}await new Promise((resolve) => setTimeout(resolve, ${durationMs(statement.duration.amount.value, statement.duration.unit)}));`;
+        case "ExpressionStatement":
+            return `${indent}${emitExpression(statement.expression)};`;
+        default:
+            return `${indent}// TODO: ${statement.type}`;
+    }
+}
+function emitEmbed(embed) {
+    const lines = ["new EmbedBuilder()"];
+    if (embed.title)
+        lines.push(`.setTitle(${emitExpression(embed.title)})`);
+    if (embed.description)
+        lines.push(`.setDescription(${emitExpression(embed.description)})`);
+    if (embed.color)
+        lines.push(`.setColor(${JSON.stringify(embed.color.value)})`);
+    for (const field of embed.fields) {
+        lines.push(`.addFields({ name: ${emitExpression(field.name)}, value: ${emitExpression(field.value)} })`);
+    }
+    return lines.join("");
+}
+function emitExpression(expression) {
+    switch (expression.type) {
+        case "StringLiteral":
+            if (expression.interpolated) {
+                // Replace {expr} placeholders with properly emitted expressions
+                let result = expression.value.replace(/`/g, "\\`");
+                // Find all {expr} patterns and replace them
+                result = result.replace(/\{([^}]+)\}/g, (match, exprContent) => {
+                    // Map user.name to user.username for Discord.js v14 compatibility
+                    if (exprContent === "user.name") {
+                        return "${user.username}";
+                    }
+                    if (exprContent === "member.name") {
+                        return "${member.user.username}";
+                    }
+                    return "${" + exprContent + "}";
+                });
+                return "`" + result + "`";
+            }
+            return JSON.stringify(expression.value);
+        case "NumberLiteral":
+            return String(expression.value);
+        case "BooleanLiteral":
+            return String(expression.value);
+        case "ColorLiteral":
+            return JSON.stringify(expression.value);
+        case "IdentifierExpr":
+            return expression.name;
+        case "MemberExpr":
+            // Map user.name to user.username for Discord.js v14 compatibility
+            if (expression.path.join(".") === "user.name") {
+                return "user.username";
+            }
+            // Map member.name to member.user.username for Discord.js v14 compatibility
+            if (expression.path.join(".") === "member.name") {
+                return "member.user.username";
+            }
+            return expression.path.join(".");
+        case "ArgsIndexExpr":
+            return `args[${expression.index}]`;
+        case "LoadExpr":
+            return `loadValue(${emitExpression(expression.namespace)}, ${JSON.stringify(expression.key)}${expression.fallback ? `, ${emitExpression(expression.fallback)}` : ""})`;
+        case "FetchExpr":
+            return `(await axios.get(${emitExpression(expression.url)})).data`;
+        case "BinaryExpr":
+            if (expression.operator === "or") {
+                return `(${emitExpression(expression.left)} ?? ${emitExpression(expression.right)})`;
+            }
+            if (expression.operator === "has") {
+                return `(message.member?.roles?.cache?.some((role) => role.name === ${emitExpression(expression.right)}) ?? false)`;
+            }
+            return `(${emitExpression(expression.left)} ${expression.operator} ${emitExpression(expression.right)})`;
+        case "UnaryExpr":
+            return `(${expression.operator}${emitExpression(expression.argument)})`;
+        case "CallExpr":
+            return `${expression.callee}(${expression.args.map(emitExpression).join(", ")})`;
+        default:
+            return "undefined";
+    }
+}
+function durationMs(amount, unit) {
+    const multipliers = {
+        second: 1000,
+        seconds: 1000,
+        minute: 60000,
+        minutes: 60000,
+        hour: 3600000,
+        hours: 3600000,
+        day: 86400000,
+        days: 86400000
+    };
+    return amount * (multipliers[unit] ?? 1000);
+}

package/dist/src/errors.d.ts

@@ -0,0 +1,31 @@
+export type NewtErrorSeverity = "error" | "warning";
+export type NewtErrorCode = "NEWT_E001" | "NEWT_E002" | "NEWT_E003" | "NEWT_E004" | "NEWT_E005" | "NEWT_E006" | "NEWT_E007" | "NEWT_E008" | "NEWT_E009" | "NEWT_E010" | "NEWT_E011" | "NEWT_E012" | "NEWT_E013" | "NEWT_E014" | "NEWT_E015";
+export interface NewtErrorOptions {
+    code: NewtErrorCode;
+    message: string;
+    line: number;
+    column: number;
+    sourceLine?: string;
+    suggestion?: string;
+    severity?: NewtErrorSeverity;
+    filename?: string;
+    length?: number;
+}
+export declare class NewtError extends Error {
+    readonly code: NewtErrorCode;
+    readonly line: number;
+    readonly column: number;
+    readonly sourceLine?: string;
+    readonly suggestion?: string;
+    readonly severity: NewtErrorSeverity;
+    readonly filename?: string;
+    readonly length: number;
+    constructor(options: NewtErrorOptions);
+}
+export declare const errorCatalog: Record<NewtErrorCode, {
+    message: string;
+    suggestion: string;
+    severity?: NewtErrorSeverity;
+}>;
+export declare function makeCatalogError(code: NewtErrorCode, line: number, column: number, sourceLine?: string, overrides?: Partial<NewtErrorOptions>): NewtError;
+export declare function formatError(error: NewtError, sourceOrFilename?: string): string;

package/dist/src/errors.js

@@ -0,0 +1,120 @@
+export class NewtError extends Error {
+    code;
+    line;
+    column;
+    sourceLine;
+    suggestion;
+    severity;
+    filename;
+    length;
+    constructor(options) {
+        super(options.message);
+        this.name = "NewtError";
+        this.code = options.code;
+        this.line = options.line;
+        this.column = options.column;
+        this.sourceLine = options.sourceLine;
+        this.suggestion = options.suggestion;
+        this.severity = options.severity ?? "error";
+        this.filename = options.filename;
+        this.length = options.length ?? 1;
+    }
+}
+export const errorCatalog = {
+    NEWT_E001: {
+        message: "Strings must be in quotes.",
+        suggestion: "Wrap the text in double quotes, like: reply \"Hello!\""
+    },
+    NEWT_E002: {
+        message: "Event handlers need a colon at the end.",
+        suggestion: "Try ending the line with a colon, like: on command \"hello\":"
+    },
+    NEWT_E003: {
+        message: "That is not a known event name.",
+        suggestion: "Try one of: on ready, on command, on join, on leave, on message contains, or on reaction add."
+    },
+    NEWT_E004: {
+        message: "This line needs to be inside a handler.",
+        suggestion: "Put this action under a line like: on command \"hello\":"
+    },
+    NEWT_E005: {
+        message: "[SECURITY WARNING] Never put your bot token directly in the file.",
+        suggestion: "Use: bot token from env \"DISCORD_TOKEN\"",
+        severity: "warning"
+    },
+    NEWT_E006: {
+        message: "Indentation looks off on this line.",
+        suggestion: "Use 2 or 4 spaces consistently within the file."
+    },
+    NEWT_E007: {
+        message: "This variable has not been defined yet.",
+        suggestion: "Add a let line before using it, like: let name = \"Newt\""
+    },
+    NEWT_E008: {
+        message: "Your bot needs a name.",
+        suggestion: "Add a line near the top: bot name \"MyBot\""
+    },
+    NEWT_E009: {
+        message: "Your bot needs a token source.",
+        suggestion: "Add: bot token from env \"DISCORD_TOKEN\""
+    },
+    NEWT_E010: {
+        message: "Embed colors must be hex colors.",
+        suggestion: "Use a six-digit color like: color #5865F2"
+    },
+    NEWT_E011: {
+        message: "Network requests should have an error fallback.",
+        suggestion: "Put fetch inside try: and add an on error: block."
+    },
+    NEWT_E012: {
+        message: "target only works when a command message mentions someone.",
+        suggestion: "Make sure this command is used like: !mute @Someone"
+    },
+    NEWT_E013: {
+        message: "That built-in variable does not exist.",
+        suggestion: "Use a built-in like user.name, message.content, channel.name, server.name, args, or target."
+    },
+    NEWT_E014: {
+        message: "Timer intervals must be greater than zero.",
+        suggestion: "Use a positive interval, like: every 1 hour:"
+    },
+    NEWT_E015: {
+        message: "Role names cannot be empty.",
+        suggestion: "Use a real role name, like: require role \"Moderator\""
+    }
+};
+export function makeCatalogError(code, line, column, sourceLine, overrides = {}) {
+    const entry = errorCatalog[code];
+    return new NewtError({
+        code,
+        line,
+        column,
+        sourceLine,
+        message: entry.message,
+        suggestion: entry.suggestion,
+        severity: entry.severity,
+        ...overrides
+    });
+}
+export function formatError(error, sourceOrFilename = "") {
+    const filename = error.filename ?? (sourceOrFilename.includes("\n") ? "input.newt" : sourceOrFilename || "input.newt");
+    const sourceLine = error.sourceLine ?? getSourceLine(sourceOrFilename, error.line);
+    const label = error.severity === "warning" ? "Warning" : "Error";
+    const caretOffset = Math.max(0, error.column - 1);
+    const caretLength = Math.max(1, error.length);
+    const caretLine = `${" ".repeat(caretOffset)}${"^".repeat(caretLength)}`;
+    const suggestion = error.suggestion ? ` ${error.suggestion}` : "";
+    return [
+        `${label} [${error.code}] on line ${error.line} in ${filename}:`,
+        "",
+        `    ${sourceLine}`,
+        `    ${caretLine}`,
+        `${error.message}${suggestion}`
+    ].join("\n");
+}
+function getSourceLine(source, line) {
+    if (!source.includes("\n")) {
+        return "";
+    }
+    return source.split(/\r?\n/)[line - 1] ?? "";
+}

package/dist/src/index.d.ts

@@ -0,0 +1,17 @@
+import { type GeneratedProject } from "./codegen.js";
+import { NewtError } from "./errors.js";
+export interface CompileSuccess extends GeneratedProject {
+    success: true;
+}
+export interface CompileFailure {
+    success: false;
+    errors: NewtError[];
+}
+export type CompileResult = CompileSuccess | CompileFailure;
+export declare function compile(source: string, filename?: string): CompileResult;
+export { generate } from "./codegen.js";
+export { formatError, NewtError } from "./errors.js";
+export { tokenize, type Token, type TokenType } from "./lexer.js";
+export { parse } from "./parser.js";
+export { validate } from "./validator.js";
+export type * from "./ast.js";