@axintai/compiler 0.2.1

package/dist/cli/index.js

@@ -0,0 +1,868 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/core/compiler.ts
+import { readFileSync } from "fs";
+
+// src/core/parser.ts
+import ts from "typescript";
+
+// src/core/types.ts
+var PARAM_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "int",
+  "double",
+  "float",
+  "boolean",
+  "date",
+  "duration",
+  "url"
+]);
+var LEGACY_PARAM_ALIASES = {
+  number: "int"
+};
+var SWIFT_TYPE_MAP = {
+  string: "String",
+  int: "Int",
+  double: "Double",
+  float: "Float",
+  boolean: "Bool",
+  date: "Date",
+  duration: "Measurement<UnitDuration>",
+  url: "URL"
+};
+function irTypeToSwift(type) {
+  switch (type.kind) {
+    case "primitive":
+      return SWIFT_TYPE_MAP[type.value];
+    case "array":
+      return `[${irTypeToSwift(type.elementType)}]`;
+    case "optional":
+      return `${irTypeToSwift(type.innerType)}?`;
+    case "entity":
+      return type.entityName;
+    case "enum":
+      return type.name;
+  }
+}
+
+// src/core/parser.ts
+function parseIntentSource(source, filePath = "<stdin>") {
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    // setParentNodes
+    ts.ScriptKind.TS
+  );
+  const defineIntentCall = findDefineIntentCall(sourceFile);
+  if (!defineIntentCall) {
+    throw new ParserError(
+      "AX001",
+      `No defineIntent() call found in ${filePath}`,
+      filePath,
+      void 0,
+      "Ensure your file contains a `defineIntent({ ... })` call."
+    );
+  }
+  const arg = defineIntentCall.arguments[0];
+  if (!arg || !ts.isObjectLiteralExpression(arg)) {
+    throw new ParserError(
+      "AX001",
+      "defineIntent() must be called with an object literal",
+      filePath,
+      posOf(sourceFile, defineIntentCall),
+      "Pass an object: defineIntent({ name, title, description, params, perform })"
+    );
+  }
+  const props = propertyMap(arg);
+  const name = readStringLiteral(props.get("name"));
+  const title = readStringLiteral(props.get("title"));
+  const description = readStringLiteral(props.get("description"));
+  const domain = readStringLiteral(props.get("domain"));
+  const category = readStringLiteral(props.get("category"));
+  const isDiscoverable = readBooleanLiteral(props.get("isDiscoverable"));
+  if (!name) {
+    throw new ParserError(
+      "AX002",
+      "Missing required field: name",
+      filePath,
+      posOf(sourceFile, arg),
+      'Add a name field: name: "MyIntent"'
+    );
+  }
+  if (!title) {
+    throw new ParserError(
+      "AX003",
+      "Missing required field: title",
+      filePath,
+      posOf(sourceFile, arg),
+      'Add a title field: title: "My Intent Title"'
+    );
+  }
+  if (!description) {
+    throw new ParserError(
+      "AX004",
+      "Missing required field: description",
+      filePath,
+      posOf(sourceFile, arg),
+      'Add a description field: description: "What this intent does"'
+    );
+  }
+  const paramsNode = props.get("params");
+  const parameters = paramsNode ? extractParameters(paramsNode, filePath, sourceFile) : [];
+  const performNode = props.get("perform");
+  const returnType = inferReturnType(performNode);
+  const entitlementsNode = props.get("entitlements");
+  const entitlements = readStringArray(entitlementsNode);
+  const infoPlistNode = props.get("infoPlistKeys");
+  const infoPlistKeys = readStringRecord(infoPlistNode);
+  return {
+    name,
+    title,
+    description,
+    domain: domain || void 0,
+    category: category || void 0,
+    parameters,
+    returnType,
+    sourceFile: filePath,
+    entitlements: entitlements.length > 0 ? entitlements : void 0,
+    infoPlistKeys: Object.keys(infoPlistKeys).length > 0 ? infoPlistKeys : void 0,
+    isDiscoverable: isDiscoverable ?? void 0
+  };
+}
+function findDefineIntentCall(node) {
+  let found;
+  const visit = (n) => {
+    if (found) return;
+    if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && n.expression.text === "defineIntent") {
+      found = n;
+      return;
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(node);
+  return found;
+}
+function propertyMap(obj) {
+  const map = /* @__PURE__ */ new Map();
+  for (const prop of obj.properties) {
+    if (ts.isPropertyAssignment(prop)) {
+      const key = propertyKeyName(prop.name);
+      if (key) map.set(key, prop.initializer);
+    } else if (ts.isShorthandPropertyAssignment(prop)) {
+      map.set(prop.name.text, prop.name);
+    } else if (ts.isMethodDeclaration(prop)) {
+      const key = propertyKeyName(prop.name);
+      if (key) map.set(key, prop);
+    }
+  }
+  return map;
+}
+function propertyKeyName(name) {
+  if (ts.isIdentifier(name)) return name.text;
+  if (ts.isStringLiteral(name)) return name.text;
+  if (ts.isNumericLiteral(name)) return name.text;
+  return void 0;
+}
+function readStringLiteral(node) {
+  if (!node) return null;
+  if (ts.isStringLiteral(node)) return node.text;
+  if (ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  return null;
+}
+function readBooleanLiteral(node) {
+  if (!node) return void 0;
+  if (node.kind === ts.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === ts.SyntaxKind.FalseKeyword) return false;
+  return void 0;
+}
+function readStringArray(node) {
+  if (!node || !ts.isArrayLiteralExpression(node)) return [];
+  const out = [];
+  for (const el of node.elements) {
+    const s = readStringLiteral(el);
+    if (s !== null) out.push(s);
+  }
+  return out;
+}
+function readStringRecord(node) {
+  if (!node || !ts.isObjectLiteralExpression(node)) return {};
+  const rec = {};
+  for (const prop of node.properties) {
+    if (!ts.isPropertyAssignment(prop)) continue;
+    const key = propertyKeyName(prop.name);
+    const val = readStringLiteral(prop.initializer);
+    if (key && val !== null) rec[key] = val;
+  }
+  return rec;
+}
+function extractParameters(node, filePath, sourceFile) {
+  if (!ts.isObjectLiteralExpression(node)) {
+    throw new ParserError(
+      "AX006",
+      "`params` must be an object literal",
+      filePath,
+      posOf(sourceFile, node),
+      "Use params: { name: param.string(...), ... }"
+    );
+  }
+  const params = [];
+  for (const prop of node.properties) {
+    if (!ts.isPropertyAssignment(prop)) continue;
+    const paramName = propertyKeyName(prop.name);
+    if (!paramName) continue;
+    const { typeName, description, configObject } = extractParamCall(
+      prop.initializer,
+      filePath,
+      sourceFile
+    );
+    const resolvedType = resolveParamType(typeName, filePath, sourceFile, prop);
+    const isOptional = configObject ? readBooleanLiteral(configObject.get("required")) === false : false;
+    const defaultExpr = configObject?.get("default");
+    const defaultValue = defaultExpr ? evaluateLiteral(defaultExpr) : void 0;
+    const titleFromConfig = configObject ? readStringLiteral(configObject.get("title")) : null;
+    const irType = isOptional ? {
+      kind: "optional",
+      innerType: { kind: "primitive", value: resolvedType }
+    } : { kind: "primitive", value: resolvedType };
+    params.push({
+      name: paramName,
+      type: irType,
+      title: titleFromConfig || prettyTitle(paramName),
+      description,
+      isOptional,
+      defaultValue
+    });
+  }
+  return params;
+}
+function extractParamCall(expr, filePath, sourceFile) {
+  if (!ts.isCallExpression(expr)) {
+    throw new ParserError(
+      "AX007",
+      "Parameter value must be a call to a param.* helper",
+      filePath,
+      posOf(sourceFile, expr),
+      "Use param.string(...), param.int(...), param.date(...), etc."
+    );
+  }
+  if (!ts.isPropertyAccessExpression(expr.expression) || !ts.isIdentifier(expr.expression.expression) || expr.expression.expression.text !== "param") {
+    throw new ParserError(
+      "AX007",
+      "Parameter value must be a call to a param.* helper",
+      filePath,
+      posOf(sourceFile, expr),
+      "Use param.string(...), param.int(...), param.date(...), etc."
+    );
+  }
+  const typeName = expr.expression.name.text;
+  const descriptionArg = expr.arguments[0];
+  const configArg = expr.arguments[1];
+  const description = descriptionArg ? readStringLiteral(descriptionArg) : null;
+  if (description === null) {
+    throw new ParserError(
+      "AX008",
+      `param.${typeName}() requires a string description as the first argument`,
+      filePath,
+      posOf(sourceFile, expr),
+      `Example: param.${typeName}("Human-readable description")`
+    );
+  }
+  const configObject = configArg && ts.isObjectLiteralExpression(configArg) ? propertyMap(configArg) : null;
+  return { typeName, description, configObject };
+}
+function resolveParamType(typeName, filePath, sourceFile, node) {
+  if (PARAM_TYPES.has(typeName)) {
+    return typeName;
+  }
+  if (typeName in LEGACY_PARAM_ALIASES) {
+    return LEGACY_PARAM_ALIASES[typeName];
+  }
+  throw new ParserError(
+    "AX005",
+    `Unknown param type: param.${typeName}`,
+    filePath,
+    posOf(sourceFile, node),
+    `Supported types: ${[...PARAM_TYPES].join(", ")}`
+  );
+}
+function evaluateLiteral(node) {
+  if (ts.isStringLiteral(node)) return node.text;
+  if (ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  if (ts.isNumericLiteral(node)) return Number(node.text);
+  if (node.kind === ts.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === ts.SyntaxKind.FalseKeyword) return false;
+  if (node.kind === ts.SyntaxKind.NullKeyword) return null;
+  if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(node.operand)) {
+    return -Number(node.operand.text);
+  }
+  return void 0;
+}
+function inferReturnType(performNode) {
+  const defaultType = { kind: "primitive", value: "string" };
+  if (!performNode) return defaultType;
+  if (ts.isMethodDeclaration(performNode)) {
+    return inferFromReturnStatements(performNode.body);
+  }
+  if (ts.isArrowFunction(performNode)) {
+    if (performNode.body && ts.isBlock(performNode.body)) {
+      return inferFromReturnStatements(performNode.body);
+    }
+    return inferFromExpression(performNode.body);
+  }
+  if (ts.isFunctionExpression(performNode)) {
+    return inferFromReturnStatements(performNode.body);
+  }
+  return defaultType;
+}
+function inferFromReturnStatements(block) {
+  const defaultType = { kind: "primitive", value: "string" };
+  if (!block) return defaultType;
+  let inferred;
+  const visit = (n) => {
+    if (inferred) return;
+    if (ts.isReturnStatement(n) && n.expression) {
+      inferred = inferFromExpression(n.expression);
+      return;
+    }
+    if (ts.isFunctionDeclaration(n) || ts.isFunctionExpression(n) || ts.isArrowFunction(n)) {
+      return;
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(block);
+  return inferred ?? defaultType;
+}
+function inferFromExpression(expr) {
+  if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
+    return { kind: "primitive", value: "string" };
+  }
+  if (ts.isNumericLiteral(expr)) {
+    return expr.text.includes(".") ? { kind: "primitive", value: "double" } : { kind: "primitive", value: "int" };
+  }
+  if (expr.kind === ts.SyntaxKind.TrueKeyword || expr.kind === ts.SyntaxKind.FalseKeyword) {
+    return { kind: "primitive", value: "boolean" };
+  }
+  return { kind: "primitive", value: "string" };
+}
+function prettyTitle(name) {
+  const spaced = name.replace(/([A-Z])/g, " $1").trim();
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+function posOf(sourceFile, node) {
+  try {
+    const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    return line + 1;
+  } catch {
+    return void 0;
+  }
+}
+var ParserError = class extends Error {
+  constructor(code, message, file, line, suggestion) {
+    super(message);
+    this.code = code;
+    this.file = file;
+    this.line = line;
+    this.suggestion = suggestion;
+    this.name = "ParserError";
+  }
+  code;
+  file;
+  line;
+  suggestion;
+  format() {
+    let output = `
+  error[${this.code}]: ${this.message}
+`;
+    if (this.file) output += `    --> ${this.file}`;
+    if (this.line) output += `:${this.line}`;
+    output += "\n";
+    if (this.suggestion) {
+      output += `    = help: ${this.suggestion}
+`;
+    }
+    return output;
+  }
+};
+
+// src/core/generator.ts
+function escapeSwiftString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function generateSwift(intent) {
+  const lines = [];
+  lines.push(`// ${intent.name}Intent.swift`);
+  lines.push(`// Generated by Axint \u2014 https://github.com/agenticempire/axint`);
+  lines.push(`// Do not edit manually. Re-run \`axint compile\` to regenerate.`);
+  lines.push(``);
+  lines.push(`import AppIntents`);
+  lines.push(`import Foundation`);
+  lines.push(``);
+  lines.push(`struct ${intent.name}Intent: AppIntent {`);
+  lines.push(
+    `    static let title: LocalizedStringResource = "${escapeSwiftString(intent.title)}"`
+  );
+  lines.push(
+    `    static let description: IntentDescription = IntentDescription("${escapeSwiftString(intent.description)}")`
+  );
+  if (intent.isDiscoverable !== void 0) {
+    lines.push(`    static let isDiscoverable: Bool = ${intent.isDiscoverable}`);
+  }
+  lines.push(``);
+  for (const param of intent.parameters) {
+    lines.push(generateParameter(param));
+  }
+  if (intent.parameters.length > 0) {
+    lines.push(``);
+  }
+  const returnTypeSignature = generateReturnSignature(intent.returnType);
+  lines.push(`    func perform() async throws -> ${returnTypeSignature} {`);
+  lines.push(`        // TODO: Implement your intent logic here.`);
+  if (intent.parameters.length > 0) {
+    const paramList = intent.parameters.map((p) => `\\(${p.name})`).join(", ");
+    lines.push(`        // Parameters available: ${paramList}`);
+  }
+  lines.push(generatePerformReturn(intent.returnType));
+  lines.push(`    }`);
+  lines.push(`}`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateInfoPlistFragment(intent) {
+  const keys = intent.infoPlistKeys;
+  if (!keys || Object.keys(keys).length === 0) return void 0;
+  const lines = [];
+  lines.push(`<?xml version="1.0" encoding="UTF-8"?>`);
+  lines.push(
+    `<!-- Info.plist fragment generated by Axint for ${intent.name}Intent -->`
+  );
+  lines.push(`<!-- Merge these keys into your app's Info.plist. -->`);
+  lines.push(`<plist version="1.0">`);
+  lines.push(`<dict>`);
+  for (const [key, desc] of Object.entries(keys)) {
+    lines.push(`    <key>${escapeXml(key)}</key>`);
+    lines.push(`    <string>${escapeXml(desc)}</string>`);
+  }
+  lines.push(`</dict>`);
+  lines.push(`</plist>`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateEntitlementsFragment(intent) {
+  const ents = intent.entitlements;
+  if (!ents || ents.length === 0) return void 0;
+  const lines = [];
+  lines.push(`<?xml version="1.0" encoding="UTF-8"?>`);
+  lines.push(
+    `<!-- Entitlements fragment generated by Axint for ${intent.name}Intent -->`
+  );
+  lines.push(`<!-- Merge these into your target's .entitlements file. -->`);
+  lines.push(`<!-- Note: entitlements requiring typed values (string/array) -->`);
+  lines.push(`<!-- need manual adjustment \u2014 defaults below are boolean true. -->`);
+  lines.push(
+    `<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">`
+  );
+  lines.push(`<plist version="1.0">`);
+  lines.push(`<dict>`);
+  for (const ent of ents) {
+    lines.push(`    <key>${escapeXml(ent)}</key>`);
+    lines.push(`    <true/>`);
+  }
+  lines.push(`</dict>`);
+  lines.push(`</plist>`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateParameter(param) {
+  const swiftType = irTypeToSwift(param.type);
+  const lines = [];
+  const attrs = [];
+  attrs.push(`title: "${escapeSwiftString(param.title)}"`);
+  if (param.description) {
+    attrs.push(`description: "${escapeSwiftString(param.description)}"`);
+  }
+  const decorator = `    @Parameter(${attrs.join(", ")})`;
+  lines.push(decorator);
+  if (param.defaultValue !== void 0) {
+    const defaultStr = formatSwiftDefault(param.defaultValue, param.type);
+    lines.push(`    var ${param.name}: ${swiftType} = ${defaultStr}`);
+  } else {
+    lines.push(`    var ${param.name}: ${swiftType}`);
+  }
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateReturnSignature(type) {
+  if (type.kind === "primitive") {
+    const swift = irTypeToSwift(type);
+    return `some IntentResult & ReturnsValue<${swift}>`;
+  }
+  if (type.kind === "optional" && type.innerType.kind === "primitive") {
+    const swift = irTypeToSwift(type.innerType);
+    return `some IntentResult & ReturnsValue<${swift}>`;
+  }
+  return `some IntentResult`;
+}
+function generatePerformReturn(type) {
+  const indent = "        ";
+  if (type.kind === "primitive") {
+    return `${indent}return .result(value: ${defaultLiteralFor(type.value)})`;
+  }
+  if (type.kind === "optional" && type.innerType.kind === "primitive") {
+    return `${indent}return .result(value: ${defaultLiteralFor(type.innerType.value)})`;
+  }
+  return `${indent}return .result()`;
+}
+function defaultLiteralFor(primitive) {
+  switch (primitive) {
+    case "string":
+      return `""`;
+    case "int":
+      return `0`;
+    case "double":
+      return `0.0`;
+    case "float":
+      return `Float(0)`;
+    case "boolean":
+      return `false`;
+    case "date":
+      return `Date()`;
+    case "duration":
+      return `Measurement<UnitDuration>(value: 0, unit: .seconds)`;
+    case "url":
+      return `URL(string: "about:blank")!`;
+    default:
+      return `""`;
+  }
+}
+function formatSwiftDefault(value, _type) {
+  if (typeof value === "string") return `"${escapeSwiftString(value)}"`;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return `0`;
+    return `${value}`;
+  }
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return `"${escapeSwiftString(String(value))}"`;
+}
+
+// src/core/validator.ts
+var MAX_PARAMETERS = 10;
+var MAX_TITLE_LENGTH = 60;
+function validateIntent(intent) {
+  const diagnostics = [];
+  if (!intent.name || !/^[A-Z][a-zA-Z0-9]*$/.test(intent.name)) {
+    diagnostics.push({
+      code: "AX100",
+      severity: "error",
+      message: `Intent name "${intent.name}" must be PascalCase (e.g., "CreateEvent")`,
+      file: intent.sourceFile,
+      suggestion: `Rename to "${toPascalCase(intent.name)}"`
+    });
+  }
+  if (!intent.title || intent.title.trim().length === 0) {
+    diagnostics.push({
+      code: "AX101",
+      severity: "error",
+      message: "Intent title must not be empty",
+      file: intent.sourceFile,
+      suggestion: "Add a human-readable title for Siri and Shortcuts display"
+    });
+  }
+  if (!intent.description || intent.description.trim().length === 0) {
+    diagnostics.push({
+      code: "AX102",
+      severity: "error",
+      message: "Intent description must not be empty",
+      file: intent.sourceFile,
+      suggestion: "Add a description explaining what this intent does"
+    });
+  }
+  for (const param of intent.parameters) {
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(param.name)) {
+      diagnostics.push({
+        code: "AX103",
+        severity: "error",
+        message: `Parameter name "${param.name}" is not a valid Swift identifier`,
+        file: intent.sourceFile,
+        suggestion: `Rename to "${param.name.replace(/[^a-zA-Z0-9_]/g, "_")}"`
+      });
+    }
+    if (!param.description || param.description.trim().length === 0) {
+      diagnostics.push({
+        code: "AX104",
+        severity: "warning",
+        message: `Parameter "${param.name}" has no description \u2014 Siri will display it without context`,
+        file: intent.sourceFile,
+        suggestion: "Add a description for better Siri/Shortcuts display"
+      });
+    }
+  }
+  if (intent.parameters.length > MAX_PARAMETERS) {
+    diagnostics.push({
+      code: "AX105",
+      severity: "warning",
+      message: `Intent has ${intent.parameters.length} parameters. Apple recommends ${MAX_PARAMETERS} or fewer for usability.`,
+      file: intent.sourceFile,
+      suggestion: "Consider splitting into multiple intents or grouping parameters into an entity"
+    });
+  }
+  if (intent.title && intent.title.length > MAX_TITLE_LENGTH) {
+    diagnostics.push({
+      code: "AX106",
+      severity: "warning",
+      message: `Intent title is ${intent.title.length} characters. Siri display may truncate titles over ${MAX_TITLE_LENGTH} characters.`,
+      file: intent.sourceFile
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const param of intent.parameters) {
+    if (seen.has(param.name)) {
+      diagnostics.push({
+        code: "AX107",
+        severity: "error",
+        message: `Duplicate parameter name "${param.name}"`,
+        file: intent.sourceFile,
+        suggestion: "Each parameter in a single intent must have a unique name"
+      });
+    }
+    seen.add(param.name);
+  }
+  for (const ent of intent.entitlements ?? []) {
+    if (!/^[a-zA-Z0-9._-]+$/.test(ent) || !ent.includes(".")) {
+      diagnostics.push({
+        code: "AX108",
+        severity: "warning",
+        message: `Entitlement "${ent}" does not look like a valid reverse-DNS identifier`,
+        file: intent.sourceFile,
+        suggestion: 'Use reverse-DNS, e.g., "com.apple.developer.siri" or "com.apple.security.app-sandbox"'
+      });
+    }
+  }
+  for (const key of Object.keys(intent.infoPlistKeys ?? {})) {
+    if (!/^(NS|UI|LS|CF|CA|CK)[A-Za-z0-9]+$/.test(key)) {
+      diagnostics.push({
+        code: "AX109",
+        severity: "warning",
+        message: `Info.plist key "${key}" does not match Apple's usual naming conventions`,
+        file: intent.sourceFile,
+        suggestion: 'Apple keys generally start with "NS" (e.g., "NSCalendarsUsageDescription")'
+      });
+    }
+  }
+  return diagnostics;
+}
+function validateSwiftSource(swift) {
+  const diagnostics = [];
+  if (!swift.includes("import AppIntents")) {
+    diagnostics.push({
+      code: "AX200",
+      severity: "error",
+      message: 'Generated Swift is missing "import AppIntents"'
+    });
+  }
+  if (!swift.includes(": AppIntent")) {
+    diagnostics.push({
+      code: "AX201",
+      severity: "error",
+      message: "Generated struct does not conform to AppIntent protocol"
+    });
+  }
+  if (!swift.includes("func perform()")) {
+    diagnostics.push({
+      code: "AX202",
+      severity: "error",
+      message: "Generated struct is missing the perform() function"
+    });
+  }
+  return diagnostics;
+}
+function toPascalCase(s) {
+  if (!s) return "UnnamedIntent";
+  return s.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (c) => c.toUpperCase());
+}
+
+// src/core/compiler.ts
+function compileFile(filePath, options = {}) {
+  let source;
+  try {
+    source = readFileSync(filePath, "utf-8");
+  } catch (_err) {
+    return {
+      success: false,
+      diagnostics: [
+        {
+          code: "AX000",
+          severity: "error",
+          message: `Cannot read file: ${filePath}`,
+          file: filePath
+        }
+      ]
+    };
+  }
+  return compileSource(source, filePath, options);
+}
+function compileSource(source, fileName = "<stdin>", options = {}) {
+  const diagnostics = [];
+  let ir;
+  try {
+    ir = parseIntentSource(source, fileName);
+  } catch (err) {
+    if (err instanceof ParserError) {
+      return {
+        success: false,
+        diagnostics: [
+          {
+            code: err.code,
+            severity: "error",
+            message: err.message,
+            file: err.file,
+            line: err.line,
+            suggestion: err.suggestion
+          }
+        ]
+      };
+    }
+    throw err;
+  }
+  const irDiagnostics = validateIntent(ir);
+  diagnostics.push(...irDiagnostics);
+  if (irDiagnostics.some((d) => d.severity === "error")) {
+    return { success: false, diagnostics };
+  }
+  const swiftCode = generateSwift(ir);
+  if (options.validate !== false) {
+    const swiftDiagnostics = validateSwiftSource(swiftCode);
+    diagnostics.push(...swiftDiagnostics);
+    if (swiftDiagnostics.some((d) => d.severity === "error")) {
+      return { success: false, diagnostics };
+    }
+  }
+  const infoPlistFragment = options.emitInfoPlist ? generateInfoPlistFragment(ir) : void 0;
+  const entitlementsFragment = options.emitEntitlements ? generateEntitlementsFragment(ir) : void 0;
+  const intentFileName = `${ir.name}Intent.swift`;
+  const outputPath = options.outDir ? `${options.outDir}/${intentFileName}` : intentFileName;
+  return {
+    success: true,
+    output: {
+      outputPath,
+      swiftCode,
+      infoPlistFragment,
+      entitlementsFragment,
+      ir,
+      diagnostics
+    },
+    diagnostics
+  };
+}
+
+// src/cli/index.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(readFileSync2(resolve(__dirname, "../../package.json"), "utf-8"));
+var VERSION = pkg.version;
+var program = new Command();
+program.name("axint").description(
+  "The open-source compiler that transforms AI agent definitions into native Apple App Intents."
+).version(VERSION);
+program.command("compile").description("Compile a TypeScript intent definition into Swift").argument("<file>", "Path to the TypeScript intent definition").option("-o, --out <dir>", "Output directory for generated Swift", ".").option("--no-validate", "Skip validation of generated Swift").option("--stdout", "Print generated Swift to stdout instead of writing a file").option("--json", "Output result as JSON (machine-readable)").action(
+  (file, options) => {
+    const filePath = resolve(file);
+    try {
+      const result = compileFile(filePath, {
+        outDir: options.out,
+        validate: options.validate
+      });
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              success: result.success,
+              swift: result.output?.swiftCode ?? null,
+              outputPath: result.output?.outputPath ?? null,
+              diagnostics: result.diagnostics.map((d) => ({
+                code: d.code,
+                severity: d.severity,
+                message: d.message,
+                file: d.file,
+                line: d.line,
+                suggestion: d.suggestion
+              }))
+            },
+            null,
+            2
+          )
+        );
+        if (!result.success) process.exit(1);
+        return;
+      }
+      for (const d of result.diagnostics) {
+        const prefix = d.severity === "error" ? "\x1B[31merror\x1B[0m" : d.severity === "warning" ? "\x1B[33mwarning\x1B[0m" : "\x1B[36minfo\x1B[0m";
+        console.error(`  ${prefix}[${d.code}]: ${d.message}`);
+        if (d.file) console.error(`    --> ${d.file}${d.line ? `:${d.line}` : ""}`);
+        if (d.suggestion) console.error(`    = help: ${d.suggestion}`);
+        console.error();
+      }
+      if (!result.success || !result.output) {
+        console.error(
+          `\x1B[31mCompilation failed with ${result.diagnostics.filter((d) => d.severity === "error").length} error(s)\x1B[0m`
+        );
+        process.exit(1);
+      }
+      if (options.stdout) {
+        console.log(result.output.swiftCode);
+      } else {
+        const outPath = resolve(result.output.outputPath);
+        mkdirSync(dirname(outPath), { recursive: true });
+        writeFileSync(outPath, result.output.swiftCode, "utf-8");
+        console.log(`\x1B[32m\u2713\x1B[0m Compiled ${result.output.ir.name} \u2192 ${outPath}`);
+      }
+      const warnings = result.diagnostics.filter(
+        (d) => d.severity === "warning"
+      ).length;
+      if (warnings > 0) {
+        console.log(`  ${warnings} warning(s)`);
+      }
+    } catch (err) {
+      if (err && typeof err === "object" && "format" in err && typeof err.format === "function") {
+        console.error(err.format());
+      } else {
+        console.error(`\x1B[31merror:\x1B[0m ${err}`);
+      }
+      process.exit(1);
+    }
+  }
+);
+program.command("validate").description("Validate a TypeScript intent definition without generating output").argument("<file>", "Path to the TypeScript intent definition").action((file) => {
+  const filePath = resolve(file);
+  try {
+    const result = compileFile(filePath, { validate: true });
+    for (const d of result.diagnostics) {
+      const prefix = d.severity === "error" ? "\x1B[31merror\x1B[0m" : d.severity === "warning" ? "\x1B[33mwarning\x1B[0m" : "\x1B[36minfo\x1B[0m";
+      console.error(`  ${prefix}[${d.code}]: ${d.message}`);
+      if (d.suggestion) console.error(`    = help: ${d.suggestion}`);
+    }
+    if (result.success) {
+      console.log(`\x1B[32m\u2713\x1B[0m Valid intent definition`);
+    } else {
+      process.exit(1);
+    }
+  } catch (err) {
+    if (err && typeof err === "object" && "format" in err && typeof err.format === "function") {
+      console.error(err.format());
+    } else {
+      console.error(`\x1B[31merror:\x1B[0m ${err}`);
+    }
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map