@axintai/compiler 0.2.1 → 0.3.1

package/dist/cli/index.js

@@ -1,41 +1,15 @@
 #!/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 __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var SWIFT_TYPE_MAP = {
-  string: "String",
-  int: "Int",
-  double: "Double",
-  float: "Float",
-  boolean: "Bool",
-  date: "Date",
-  duration: "Measurement<UnitDuration>",
-  url: "URL"
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
+
+// src/core/types.ts
 function irTypeToSwift(type) {
   switch (type.kind) {
     case "primitive":
@@ -46,12 +20,46 @@ function irTypeToSwift(type) {
       return `${irTypeToSwift(type.innerType)}?`;
     case "entity":
       return type.entityName;
+    case "entityQuery":
+      return `${type.entityName}Query`;
+    case "dynamicOptions":
+      return `[DynamicOptionsResult<${irTypeToSwift(type.valueType)}>]`;
     case "enum":
       return type.name;
   }
 }
+var PARAM_TYPES, LEGACY_PARAM_ALIASES, SWIFT_TYPE_MAP;
+var init_types = __esm({
+  "src/core/types.ts"() {
+    "use strict";
+    PARAM_TYPES = /* @__PURE__ */ new Set([
+      "string",
+      "int",
+      "double",
+      "float",
+      "boolean",
+      "date",
+      "duration",
+      "url"
+    ]);
+    LEGACY_PARAM_ALIASES = {
+      number: "int"
+    };
+    SWIFT_TYPE_MAP = {
+      string: "String",
+      int: "Int",
+      double: "Double",
+      float: "Float",
+      boolean: "Bool",
+      date: "Date",
+      duration: "Measurement<UnitDuration>",
+      url: "URL"
+    };
+  }
+});
 
 // src/core/parser.ts
+import ts from "typescript";
 function parseIntentSource(source, filePath = "<stdin>") {
   const sourceFile = ts.createSourceFile(
     filePath,
@@ -61,6 +69,9 @@ function parseIntentSource(source, filePath = "<stdin>") {
     // setParentNodes
     ts.ScriptKind.TS
   );
+  const entities = findDefineEntityCalls(sourceFile).map(
+    (call) => parseEntityDefinition(call, filePath, sourceFile)
+  );
   const defineIntentCall = findDefineIntentCall(sourceFile);
   if (!defineIntentCall) {
     throw new ParserError(
@@ -123,6 +134,10 @@ function parseIntentSource(source, filePath = "<stdin>") {
   const entitlements = readStringArray(entitlementsNode);
   const infoPlistNode = props.get("infoPlistKeys");
   const infoPlistKeys = readStringRecord(infoPlistNode);
+  const donateOnPerformNode = props.get("donateOnPerform");
+  const donateOnPerform = readBooleanLiteral(donateOnPerformNode);
+  const customResultTypeNode = props.get("customResultType");
+  const customResultType = readStringLiteral(customResultTypeNode);
   return {
     name,
     title,
@@ -134,7 +149,10 @@ function parseIntentSource(source, filePath = "<stdin>") {
     sourceFile: filePath,
     entitlements: entitlements.length > 0 ? entitlements : void 0,
     infoPlistKeys: Object.keys(infoPlistKeys).length > 0 ? infoPlistKeys : void 0,
-    isDiscoverable: isDiscoverable ?? void 0
+    isDiscoverable: isDiscoverable ?? void 0,
+    entities: entities.length > 0 ? entities : void 0,
+    donateOnPerform: donateOnPerform ?? void 0,
+    customResultType: customResultType ?? void 0
   };
 }
 function findDefineIntentCall(node) {
@@ -150,6 +168,18 @@ function findDefineIntentCall(node) {
   visit(node);
   return found;
 }
+function findDefineEntityCalls(node) {
+  const found = [];
+  const visit = (n) => {
+    if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && n.expression.text === "defineEntity") {
+      found.push(n);
+      return;
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(node);
+  return found;
+}
 function propertyMap(obj) {
   const map = /* @__PURE__ */ new Map();
   for (const prop of obj.properties) {
@@ -203,6 +233,77 @@ function readStringRecord(node) {
   }
   return rec;
 }
+function parseEntityDefinition(call, filePath, sourceFile) {
+  const arg = call.arguments[0];
+  if (!arg || !ts.isObjectLiteralExpression(arg)) {
+    throw new ParserError(
+      "AX015",
+      "defineEntity() must be called with an object literal",
+      filePath,
+      posOf(sourceFile, call),
+      "Pass an object: defineEntity({ name, display, properties, query })"
+    );
+  }
+  const props = propertyMap(arg);
+  const name = readStringLiteral(props.get("name"));
+  if (!name) {
+    throw new ParserError(
+      "AX016",
+      "Entity definition missing required field: name",
+      filePath,
+      posOf(sourceFile, arg),
+      'Add a name field: name: "Task"'
+    );
+  }
+  const displayNode = props.get("display");
+  if (!displayNode || !ts.isObjectLiteralExpression(displayNode)) {
+    throw new ParserError(
+      "AX017",
+      "Entity definition missing required field: display",
+      filePath,
+      posOf(sourceFile, arg),
+      'Add display field: display: { title: "name", subtitle: "status" }'
+    );
+  }
+  const displayProps = propertyMap(displayNode);
+  const displayRepresentation = {
+    title: readStringLiteral(displayProps.get("title")) || "name",
+    subtitle: readStringLiteral(displayProps.get("subtitle")) || void 0,
+    image: readStringLiteral(displayProps.get("image")) || void 0
+  };
+  const propertiesNode = props.get("properties");
+  const properties = propertiesNode ? extractParameters(propertiesNode, filePath, sourceFile) : [];
+  const queryTypeNode = props.get("query");
+  const queryTypeStr = readStringLiteral(queryTypeNode);
+  const queryType = validateQueryType(queryTypeStr, filePath, sourceFile, queryTypeNode);
+  return {
+    name,
+    displayRepresentation,
+    properties,
+    queryType
+  };
+}
+function validateQueryType(value, filePath, sourceFile, node) {
+  if (!value) {
+    throw new ParserError(
+      "AX018",
+      "Entity definition missing required field: query",
+      filePath,
+      node ? posOf(sourceFile, node) : void 0,
+      'Add query field: query: "string" (or "all", "id", "property")'
+    );
+  }
+  const valid = ["all", "id", "string", "property"];
+  if (!valid.includes(value)) {
+    throw new ParserError(
+      "AX019",
+      `Invalid query type: "${value}". Must be one of: all, id, string, property`,
+      filePath,
+      node ? posOf(sourceFile, node) : void 0
+    );
+  }
+  return value;
+}
 function extractParameters(node, filePath, sourceFile) {
   if (!ts.isObjectLiteralExpression(node)) {
     throw new ParserError(
@@ -218,20 +319,20 @@ function extractParameters(node, filePath, sourceFile) {
     if (!ts.isPropertyAssignment(prop)) continue;
     const paramName = propertyKeyName(prop.name);
     if (!paramName) continue;
-    const { typeName, description, configObject } = extractParamCall(
+    const { typeName, description, configObject, callExpr } = extractParamCall(
       prop.initializer,
       filePath,
       sourceFile
     );
-    const resolvedType = resolveParamType(typeName, filePath, sourceFile, prop);
+    const resolvedType = resolveParamType(typeName, filePath, sourceFile, prop, callExpr);
     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 };
+      innerType: resolvedType
+    } : resolvedType;
     params.push({
       name: paramName,
       type: irType,
@@ -263,34 +364,98 @@ function extractParamCall(expr, filePath, sourceFile) {
     );
   }
   const typeName = expr.expression.name.text;
-  const descriptionArg = expr.arguments[0];
-  const configArg = expr.arguments[1];
+  let descriptionArg;
+  let configArg;
+  if (typeName === "entity" && expr.arguments.length >= 2) {
+    descriptionArg = expr.arguments[1];
+    configArg = expr.arguments[2];
+  } else if (typeName === "dynamicOptions" && expr.arguments.length >= 3) {
+    descriptionArg = expr.arguments[2];
+    configArg = expr.arguments[3];
+  } else {
+    descriptionArg = expr.arguments[0];
+    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`,
+      `param.${typeName}() requires a string description`,
       filePath,
       posOf(sourceFile, expr),
       `Example: param.${typeName}("Human-readable description")`
     );
   }
   const configObject = configArg && ts.isObjectLiteralExpression(configArg) ? propertyMap(configArg) : null;
-  return { typeName, description, configObject };
+  return { typeName, description, configObject, callExpr: expr };
 }
-function resolveParamType(typeName, filePath, sourceFile, node) {
+function resolveParamType(typeName, filePath, sourceFile, node, callExpr) {
   if (PARAM_TYPES.has(typeName)) {
-    return typeName;
+    return { kind: "primitive", value: typeName };
   }
   if (typeName in LEGACY_PARAM_ALIASES) {
-    return LEGACY_PARAM_ALIASES[typeName];
+    return {
+      kind: "primitive",
+      value: LEGACY_PARAM_ALIASES[typeName]
+    };
+  }
+  if (typeName === "entity") {
+    if (!callExpr || callExpr.arguments.length === 0) {
+      throw new ParserError(
+        "AX020",
+        "param.entity() requires the entity name as the first argument",
+        filePath,
+        posOf(sourceFile, node),
+        'Example: param.entity("Task", "Reference an entity")'
+      );
+    }
+    const entityName = readStringLiteral(callExpr.arguments[0]);
+    if (!entityName) {
+      throw new ParserError(
+        "AX021",
+        "param.entity() requires a string entity name",
+        filePath,
+        posOf(sourceFile, node)
+      );
+    }
+    return {
+      kind: "entity",
+      entityName,
+      properties: []
+    };
+  }
+  if (typeName === "dynamicOptions") {
+    if (!callExpr || callExpr.arguments.length < 2) {
+      throw new ParserError(
+        "AX022",
+        "param.dynamicOptions() requires (providerName, paramType)",
+        filePath,
+        posOf(sourceFile, node),
+        'Example: param.dynamicOptions("PlaylistProvider", param.string(...))'
+      );
+    }
+    const providerName = readStringLiteral(callExpr.arguments[0]);
+    if (!providerName) {
+      throw new ParserError(
+        "AX023",
+        "param.dynamicOptions() provider name must be a string",
+        filePath,
+        posOf(sourceFile, node)
+      );
+    }
+    const valueType = { kind: "primitive", value: "string" };
+    return {
+      kind: "dynamicOptions",
+      valueType,
+      providerName
+    };
   }
   throw new ParserError(
     "AX005",
     `Unknown param type: param.${typeName}`,
     filePath,
     posOf(sourceFile, node),
-    `Supported types: ${[...PARAM_TYPES].join(", ")}`
+    `Supported types: ${[...PARAM_TYPES].join(", ")}, entity, dynamicOptions`
   );
 }
 function evaluateLiteral(node) {
@@ -364,33 +529,40 @@ function posOf(sourceFile, node) {
     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 = `
+var ParserError;
+var init_parser = __esm({
+  "src/core/parser.ts"() {
+    "use strict";
+    init_types();
+    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}
+        if (this.file) output += `    --> ${this.file}`;
+        if (this.line) output += `:${this.line}`;
+        output += "\n";
+        if (this.suggestion) {
+          output += `    = help: ${this.suggestion}
 `;
-    }
-    return output;
+        }
+        return output;
+      }
+    };
   }
-};
+});
 
 // src/core/generator.ts
 function escapeSwiftString(s) {
@@ -408,6 +580,14 @@ function generateSwift(intent) {
   lines.push(`import AppIntents`);
   lines.push(`import Foundation`);
   lines.push(``);
+  if (intent.entities && intent.entities.length > 0) {
+    for (const entity of intent.entities) {
+      lines.push(generateEntity(entity));
+      lines.push(``);
+      lines.push(generateEntityQuery(entity));
+      lines.push(``);
+    }
+  }
   lines.push(`struct ${intent.name}Intent: AppIntent {`);
   lines.push(
     `    static let title: LocalizedStringResource = "${escapeSwiftString(intent.title)}"`
@@ -425,17 +605,101 @@ function generateSwift(intent) {
   if (intent.parameters.length > 0) {
     lines.push(``);
   }
-  const returnTypeSignature = generateReturnSignature(intent.returnType);
+  const returnTypeSignature = generateReturnSignature(
+    intent.returnType,
+    intent.customResultType
+  );
   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));
+  if (intent.donateOnPerform) {
+    lines.push(`        `);
+    lines.push(`        // Donate this intent to Siri and Spotlight`);
+    lines.push(`        try? await IntentDonationManager.shared.donate(intent: self)`);
+  }
+  lines.push(generatePerformReturn(intent.returnType, intent.customResultType));
+  lines.push(`    }`);
+  lines.push(`}`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateEntity(entity) {
+  const lines = [];
+  const propertyNames = new Set(entity.properties.map((p) => p.name));
+  lines.push(`struct ${entity.name}: AppEntity {`);
+  lines.push(`    static var defaultQuery = ${entity.name}Query()`);
+  lines.push(``);
+  const hasId = propertyNames.has("id");
+  if (!hasId) {
+    lines.push(`    var id: String`);
+  }
+  for (const prop of entity.properties) {
+    const swiftType = irTypeToSwift(prop.type);
+    lines.push(`    var ${prop.name}: ${swiftType}`);
+  }
+  lines.push(``);
+  lines.push(
+    `    static let typeDisplayRepresentation: TypeDisplayRepresentation = TypeDisplayRepresentation(`
+  );
+  lines.push(
+    `        name: LocalizedStringResource("${escapeSwiftString(entity.name)}")`
+  );
+  lines.push(`    )`);
+  lines.push(``);
+  lines.push(`    var displayRepresentation: DisplayRepresentation {`);
+  lines.push(`        DisplayRepresentation(`);
+  lines.push(
+    `            title: "\\(${entity.displayRepresentation.title})"${entity.displayRepresentation.subtitle || entity.displayRepresentation.image ? "," : ""}`
+  );
+  if (entity.displayRepresentation.subtitle) {
+    const hasImage = !!entity.displayRepresentation.image;
+    lines.push(
+      `            subtitle: "\\(${entity.displayRepresentation.subtitle})"${hasImage ? "," : ""}`
+    );
+  }
+  if (entity.displayRepresentation.image) {
+    lines.push(
+      `            image: .init(systemName: "${escapeSwiftString(entity.displayRepresentation.image)}")`
+    );
+  }
+  lines.push(`        )`);
   lines.push(`    }`);
   lines.push(`}`);
+  return lines.join("\n");
+}
+function generateEntityQuery(entity) {
+  const lines = [];
+  const queryType = entity.queryType;
+  lines.push(`struct ${entity.name}Query: EntityQuery {`);
+  lines.push(
+    `    func entities(for identifiers: [${entity.name}.ID]) async throws -> [${entity.name}] {`
+  );
+  lines.push(`        // TODO: Fetch entities by IDs`);
+  lines.push(`        return []`);
+  lines.push(`    }`);
   lines.push(``);
+  if (queryType === "all") {
+    lines.push(`    func allEntities() async throws -> [${entity.name}] {`);
+    lines.push(`        // TODO: Return all entities`);
+    lines.push(`        return []`);
+    lines.push(`    }`);
+  } else if (queryType === "id") {
+    lines.push(`    // ID-based query is provided by the entities(for:) method above`);
+  } else if (queryType === "string") {
+    lines.push(
+      `    func entities(matching string: String) async throws -> [${entity.name}] {`
+    );
+    lines.push(`        // TODO: Search entities by string`);
+    lines.push(`        return []`);
+    lines.push(`    }`);
+  } else if (queryType === "property") {
+    lines.push(`    // Property-based query: implement using EntityPropertyQuery`);
+    lines.push(`    // Example: property.where { \\$0.status == "active" }`);
+  }
+  lines.push(`}`);
   return lines.join("\n");
 }
 function generateInfoPlistFragment(intent) {
@@ -443,9 +707,7 @@ function generateInfoPlistFragment(intent) {
   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(`<!-- 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>`);
@@ -502,7 +764,10 @@ function generateParameter(param) {
   lines.push(``);
   return lines.join("\n");
 }
-function generateReturnSignature(type) {
+function generateReturnSignature(type, customResultType) {
+  if (customResultType) {
+    return customResultType;
+  }
   if (type.kind === "primitive") {
     const swift = irTypeToSwift(type);
     return `some IntentResult & ReturnsValue<${swift}>`;
@@ -513,8 +778,11 @@ function generateReturnSignature(type) {
   }
   return `some IntentResult`;
 }
-function generatePerformReturn(type) {
+function generatePerformReturn(type, customResultType) {
   const indent = "        ";
+  if (customResultType) {
+    return `${indent}// TODO: Return a ${customResultType} instance`;
+  }
   if (type.kind === "primitive") {
     return `${indent}return .result(value: ${defaultLiteralFor(type.value)})`;
   }
@@ -554,10 +822,14 @@ function formatSwiftDefault(value, _type) {
   if (typeof value === "boolean") return value ? "true" : "false";
   return `"${escapeSwiftString(String(value))}"`;
 }
+var init_generator = __esm({
+  "src/core/generator.ts"() {
+    "use strict";
+    init_types();
+  }
+});
 
 // 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)) {
@@ -659,6 +931,54 @@ function validateIntent(intent) {
       });
     }
   }
+  if (intent.entities) {
+    for (const entity of intent.entities) {
+      diagnostics.push(...validateEntity(entity, intent.sourceFile));
+    }
+  }
+  return diagnostics;
+}
+function validateEntity(entity, sourceFile) {
+  const diagnostics = [];
+  if (!entity.name || !/^[A-Z][a-zA-Z0-9]*$/.test(entity.name)) {
+    diagnostics.push({
+      code: "AX110",
+      severity: "error",
+      message: `Entity name "${entity.name}" must be PascalCase (e.g., "Task", "Playlist")`,
+      file: sourceFile,
+      suggestion: `Rename to "${toPascalCase(entity.name)}"`
+    });
+  }
+  if (entity.properties.length === 0) {
+    diagnostics.push({
+      code: "AX111",
+      severity: "error",
+      message: `Entity "${entity.name}" must have at least one property`,
+      file: sourceFile,
+      suggestion: "Add properties to define the entity's structure"
+    });
+  }
+  const titleProp = entity.displayRepresentation.title;
+  const propertyNames = new Set(entity.properties.map((p) => p.name));
+  if (titleProp && !propertyNames.has(titleProp)) {
+    diagnostics.push({
+      code: "AX112",
+      severity: "warning",
+      message: `Display title "${titleProp}" does not reference an existing property`,
+      file: sourceFile,
+      suggestion: `Available properties: ${[...propertyNames].join(", ")}`
+    });
+  }
+  const validQueryTypes = ["all", "id", "string", "property"];
+  if (!validQueryTypes.includes(entity.queryType)) {
+    diagnostics.push({
+      code: "AX113",
+      severity: "error",
+      message: `Entity query type "${entity.queryType}" is not valid`,
+      file: sourceFile,
+      suggestion: `Use one of: ${validQueryTypes.join(", ")}`
+    });
+  }
   return diagnostics;
 }
 function validateSwiftSource(swift) {
@@ -690,8 +1010,17 @@ function toPascalCase(s) {
   if (!s) return "UnnamedIntent";
   return s.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (c) => c.toUpperCase());
 }
+var MAX_PARAMETERS, MAX_TITLE_LENGTH;
+var init_validator = __esm({
+  "src/core/validator.ts"() {
+    "use strict";
+    MAX_PARAMETERS = 10;
+    MAX_TITLE_LENGTH = 60;
+  }
+});
 
 // src/core/compiler.ts
+import { readFileSync } from "fs";
 function compileFile(filePath, options = {}) {
   let source;
   try {
@@ -712,7 +1041,6 @@ function compileFile(filePath, options = {}) {
   return compileSource(source, filePath, options);
 }
 function compileSource(source, fileName = "<stdin>", options = {}) {
-  const diagnostics = [];
   let ir;
   try {
     ir = parseIntentSource(source, fileName);
@@ -734,6 +1062,10 @@ function compileSource(source, fileName = "<stdin>", options = {}) {
     }
     throw err;
   }
+  return compileFromIR(ir, options);
+}
+function compileFromIR(ir, options = {}) {
+  const diagnostics = [];
   const irDiagnostics = validateIntent(ir);
   diagnostics.push(...irDiagnostics);
   if (irDiagnostics.some((d) => d.severity === "error")) {
@@ -764,105 +1096,2233 @@ function compileSource(source, fileName = "<stdin>", options = {}) {
     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);
+function irFromJSON(data) {
+  const parameters = (data.parameters ?? []).map(
+    (p) => {
+      const param = p;
+      return {
+        name: param.name,
+        type: normalizeIRType(param.type),
+        title: param.title ?? param.description ?? "",
+        description: param.description ?? "",
+        isOptional: param.optional ?? param.isOptional ?? false,
+        defaultValue: param.default ?? param.defaultValue
+      };
     }
-  } 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}`);
+  );
+  return {
+    name: data.name,
+    title: data.title,
+    description: data.description,
+    domain: data.domain,
+    parameters,
+    returnType: data.returnType ? normalizeIRType(data.returnType) : { kind: "primitive", value: "string" },
+    sourceFile: data.sourceFile ?? void 0,
+    entitlements: data.entitlements ?? void 0,
+    infoPlistKeys: data.infoPlistKeys ?? void 0,
+    isDiscoverable: data.isDiscoverable ?? true
+  };
+}
+function normalizeIRType(type) {
+  if (typeof type === "string") {
+    const normalized = type === "number" ? "int" : type;
+    if (VALID_PRIMITIVES.has(normalized)) {
+      return { kind: "primitive", value: normalized };
     }
-    process.exit(1);
+    return { kind: "primitive", value: "string" };
+  }
+  if (type && typeof type === "object") {
+    const t = type;
+    if (t.kind === "primitive") return type;
+    if (t.kind === "array")
+      return { kind: "array", elementType: normalizeIRType(t.elementType) };
+    if (t.kind === "optional")
+      return { kind: "optional", innerType: normalizeIRType(t.innerType) };
+    if (t.kind === "entity") return type;
+    if (t.kind === "enum") return type;
+  }
+  return { kind: "primitive", value: "string" };
+}
+var VALID_PRIMITIVES;
+var init_compiler = __esm({
+  "src/core/compiler.ts"() {
+    "use strict";
+    init_parser();
+    init_generator();
+    init_validator();
+    VALID_PRIMITIVES = /* @__PURE__ */ new Set([
+      "string",
+      "int",
+      "double",
+      "float",
+      "boolean",
+      "date",
+      "duration",
+      "url"
+    ]);
   }
 });
-program.parse();
+
+// src/templates/index.ts
+function getTemplate(id) {
+  return TEMPLATES.find((t) => t.id === id);
+}
+function listTemplates(category) {
+  if (category) {
+    return TEMPLATES.filter((t) => t.category === category);
+  }
+  return TEMPLATES;
+}
+var sendMessage, createEvent, bookRide, getDirections, playTrack, createNote, logExpense, logWorkout, setThermostat, placeOrder, searchTasks, dynamicPlaylist, TEMPLATES;
+var init_templates = __esm({
+  "src/templates/index.ts"() {
+    "use strict";
+    sendMessage = {
+      id: "send-message",
+      name: "send-message",
+      title: "Send Message",
+      domain: "messaging",
+      category: "messaging",
+      description: "Send a text message to a contact.",
+      source: `import { defineIntent, param } from "@axintai/compiler";
+
+export default defineIntent({
+  name: "SendMessage",
+  title: "Send Message",
+  description: "Sends a message to a specified contact.",
+  domain: "messaging",
+  params: {
+    recipient: param.string("Who to send the message to"),
+    body: param.string("The message content"),
+  },
+  perform: async ({ recipient, body }) => {
+    // TODO: Integrate with your messaging backend
+    return { sent: true };
+  },
+});
+`
+    };
+    createEvent = {
+      id: "create-event",
+      name: "create-event",
+      title: "Create Calendar Event",
+      domain: "productivity",
+      category: "productivity",
+      description: "Create a calendar event with a title, date, and duration.",
+      source: `import { defineIntent, param } from "@axintai/compiler";
+
+export default defineIntent({
+  name: "CreateEvent",
+  title: "Create Calendar Event",
+  description: "Creates a new event in the user's calendar.",
+  domain: "productivity",
+  entitlements: ["com.apple.developer.siri"],
+  infoPlistKeys: {
+    NSCalendarsUsageDescription: "Access to your calendar to create events.",
+  },
+  params: {
+    title: param.string("Event title"),
+    date: param.date("Event date"),
+    durationMinutes: param.int("Duration in minutes", { default: 30 }),
+    allDay: param.boolean("All-day event", { required: false }),
+  },
+  perform: async ({ title, date }) => {
+    return { eventId: "evt_placeholder" };
+  },
+});
+`
+    };
+    bookRide = {
+      id: "book-ride",
+      name: "book-ride",
+      title: "Book a Ride",
+      domain: "navigation",
+      category: "navigation",
+      description: "Request a ride from a pickup location to a destination.",
+      source: `import { defineIntent, param } from "@axintai/compiler";
+
+export default defineIntent({
+  name: "BookRide",
+  title: "Book a Ride",
+  description: "Requests a ride from a pickup location to a destination.",
+  domain: "navigation",
+  params: {
+    pickup: param.string("Pickup location"),
+    destination: param.string("Destination address"),
+    passengers: param.int("Number of passengers", { default: 1 }),
+  },
+  perform: async ({ pickup, destination }) => {
+    return { rideId: "ride_placeholder", eta: 300 };
+  },
+});
+`
+    };
+    getDirections = {
+      id: "get-directions",
+      name: "get-directions",
+      title: "Get Directions",
+      domain: "navigation",
+      category: "navigation",
+      description: "Get turn-by-turn directions to a destination.",
+      source: `import { defineIntent, param } from "@axintai/compiler";
+
+export default defineIntent({
+  name: "GetDirections",
+  title: "Get Directions",
+  description: "Returns turn-by-turn directions to a destination.",
+  domain: "navigation",
+  params: {
+    destination: param.string("Where to navigate to"),
+    mode: param.string("Travel mode (driving, walking, transit)", {
+      default: "driving",
+    }),
+  },
+  perform: async ({ destination }) => {
+    return { routeId: "route_placeholder" };
+  },
+});
+`
+    };
+    playTrack = {
+      id: "play-track",
+      name: "play-track",
+      title: "Play Track",
+      domain: "media",
+      category: "media",
+      description: "Play a specific track or song.",
+      source: `import { defineIntent, param } from "@axintai/compiler";
+
+export default defineIntent({
+  name: "PlayTrack",
+  title: "Play Track",
+  description: "Plays a specific track by title and artist.",
+  domain: "media",
+  params: {
+    track: param.string("Track title"),
+    artist: param.string("Artist name", { required: false }),
+    shuffle: param.boolean("Shuffle mode", { required: false }),
+  },
+  perform: async ({ track }) => {
+    return { playing: true };
+  },
+});
+`
+    };
+    createNote = {
+      id: "create-note",
+      name: "create-note",
+      title: "Create Note",
+      domain: "productivity",
+      category: "productivity",
+      description: "Create a new note with a title and body.",
+      source: `import { defineIntent, param } from "@axintai/compiler";
+
+export default defineIntent({
+  name: "CreateNote",
+  title: "Create Note",
+  description: "Creates a new note with a title and body.",
+  domain: "productivity",
+  params: {
+    title: param.string("Note title"),
+    body: param.string("Note body"),
+    pinned: param.boolean("Pin the note", { required: false }),
+  },
+  perform: async ({ title, body }) => {
+    return { noteId: "note_placeholder" };
+  },
+});
+`
+    };
+    logExpense = {
+      id: "log-expense",
+      name: "log-expense",
+      title: "Log Expense",
+      domain: "finance",
+      category: "finance",
+      description: "Log a financial expense with amount, category, and note.",
+      source: `import { defineIntent, param } from "@axintai/compiler";
+
+export default defineIntent({
+  name: "LogExpense",
+  title: "Log Expense",
+  description: "Logs a financial expense with amount, category, and note.",
+  domain: "finance",
+  params: {
+    amount: param.double("Expense amount"),
+    currency: param.string("ISO currency code (e.g., USD)", {
+      default: "USD",
+    }),
+    category: param.string("Expense category"),
+    note: param.string("Optional note", { required: false }),
+  },
+  perform: async ({ amount, category }) => {
+    return { expenseId: "exp_placeholder" };
+  },
+});
+`
+    };
+    logWorkout = {
+      id: "log-workout",
+      name: "log-workout",
+      title: "Log Workout",
+      domain: "health",
+      category: "health",
+      description: "Log a workout with duration, type, and calories burned.",
+      source: `import { defineIntent, param } from "@axintai/compiler";
+
+export default defineIntent({
+  name: "LogWorkout",
+  title: "Log Workout",
+  description: "Logs a workout with duration, type, and calories burned.",
+  domain: "health",
+  entitlements: ["com.apple.developer.healthkit"],
+  infoPlistKeys: {
+    NSHealthShareUsageDescription: "Read workout history to track progress.",
+    NSHealthUpdateUsageDescription: "Save new workouts you log.",
+  },
+  params: {
+    type: param.string("Workout type (e.g., running, cycling)"),
+    duration: param.duration("Workout duration"),
+    calories: param.int("Calories burned", { required: false }),
+  },
+  perform: async ({ type, duration }) => {
+    return { workoutId: "wo_placeholder" };
+  },
+});
+`
+    };
+    setThermostat = {
+      id: "set-thermostat",
+      name: "set-thermostat",
+      title: "Set Thermostat",
+      domain: "smart-home",
+      category: "smart-home",
+      description: "Set a smart-home thermostat to a target temperature.",
+      source: `import { defineIntent, param } from "@axintai/compiler";
+
+export default defineIntent({
+  name: "SetThermostat",
+  title: "Set Thermostat",
+  description: "Sets a smart-home thermostat to a target temperature.",
+  domain: "smart-home",
+  params: {
+    room: param.string("Which room"),
+    temperature: param.double("Target temperature"),
+    unit: param.string("Temperature unit (F or C)", { default: "F" }),
+  },
+  perform: async ({ room, temperature }) => {
+    return { set: true };
+  },
+});
+`
+    };
+    placeOrder = {
+      id: "place-order",
+      name: "place-order",
+      title: "Place Order",
+      domain: "commerce",
+      category: "commerce",
+      description: "Place a commerce order for a product.",
+      source: `import { defineIntent, param } from "@axintai/compiler";
+
+export default defineIntent({
+  name: "PlaceOrder",
+  title: "Place Order",
+  description: "Places an order for a product.",
+  domain: "commerce",
+  params: {
+    productId: param.string("Product identifier"),
+    quantity: param.int("Quantity", { default: 1 }),
+    shippingAddress: param.string("Shipping address", { required: false }),
+  },
+  perform: async ({ productId, quantity }) => {
+    return { orderId: "ord_placeholder", total: 0 };
+  },
+});
+`
+    };
+    searchTasks = {
+      id: "search-tasks",
+      name: "search-tasks",
+      title: "Search Tasks",
+      domain: "productivity",
+      category: "productivity",
+      description: "Search for tasks using EntityQuery with string-based search.",
+      source: `import { defineIntent, defineEntity, param } from "@axintai/compiler";
+
+defineEntity({
+  name: "Task",
+  display: {
+    title: "name",
+    subtitle: "status",
+  },
+  properties: {
+    id: param.string("Unique task identifier"),
+    name: param.string("Task name"),
+    status: param.string("Task status (todo, in-progress, done)"),
+    dueDate: param.date("Due date"),
+  },
+  query: "string",
+});
+
+export default defineIntent({
+  name: "SearchTasks",
+  title: "Search Tasks",
+  description: "Search for tasks by name or status.",
+  domain: "productivity",
+  params: {
+    query: param.string("Search query"),
+    status: param.string("Filter by status (optional)", { required: false }),
+  },
+  donateOnPerform: true,
+  perform: async ({ query, status }) => {
+    // TODO: Search your task database with the query
+    // Use status filter if provided
+    return { found: true, results: 0 };
+  },
+});
+`
+    };
+    dynamicPlaylist = {
+      id: "dynamic-playlist",
+      name: "dynamic-playlist",
+      title: "Dynamic Playlist",
+      domain: "media",
+      category: "media",
+      description: "Create a playlist by name, mood, and track count.",
+      source: `import { defineIntent, param } from "@axintai/compiler";
+
+export default defineIntent({
+  name: "DynamicPlaylist",
+  title: "Create Dynamic Playlist",
+  description: "Create a playlist with a given mood or genre.",
+  domain: "media",
+  params: {
+    name: param.string("Playlist name"),
+    mood: param.string("Mood or genre (e.g., chill, workout, focus)"),
+    trackCount: param.int("Number of tracks", { default: 20 }),
+  },
+  perform: async ({ name, mood }) => {
+    return { playlistId: "playlist_placeholder" };
+  },
+});
+`
+    };
+    TEMPLATES = [
+      sendMessage,
+      createEvent,
+      bookRide,
+      getDirections,
+      playTrack,
+      createNote,
+      logExpense,
+      logWorkout,
+      setThermostat,
+      placeOrder,
+      searchTasks,
+      dynamicPlaylist
+    ];
+  }
+});
+
+// src/core/format.ts
+var format_exports = {};
+__export(format_exports, {
+  SWIFT_FORMAT_CONFIG: () => SWIFT_FORMAT_CONFIG,
+  formatSwift: () => formatSwift
+});
+import { spawn as spawn2 } from "child_process";
+import { writeFile as writeFile2, unlink } from "fs/promises";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
+async function formatSwift(source, options = {}) {
+  const available = await hasSwiftFormat();
+  if (!available) {
+    if (options.strict) {
+      throw new Error(
+        "swift-format not found on $PATH. Install Xcode + Command Line Tools, or drop --format."
+      );
+    }
+    return {
+      formatted: source,
+      ran: false,
+      reason: "swift-format not found on $PATH"
+    };
+  }
+  const configPath = join2(
+    tmpdir(),
+    `axint-swift-format-${Date.now()}-${Math.random().toString(36).slice(2)}.json`
+  );
+  await writeFile2(configPath, JSON.stringify(SWIFT_FORMAT_CONFIG, null, 2));
+  try {
+    const result = await runSwiftFormat(source, configPath, options.timeoutMs ?? 8e3);
+    if (result.code === 0) {
+      return { formatted: result.stdout, ran: true };
+    }
+    if (options.strict) {
+      throw new Error(`swift-format failed: ${result.stderr}`);
+    }
+    return {
+      formatted: source,
+      ran: false,
+      reason: `swift-format exited ${result.code}: ${result.stderr}`
+    };
+  } finally {
+    await unlink(configPath).catch(() => void 0);
+  }
+}
+function hasSwiftFormat() {
+  return new Promise((resolve3) => {
+    const child = spawn2("swift-format", ["--version"], { stdio: "pipe" });
+    child.on("error", () => resolve3(false));
+    child.on("exit", (code) => resolve3(code === 0));
+  });
+}
+function runSwiftFormat(source, configPath, timeoutMs) {
+  return new Promise((resolve3) => {
+    const child = spawn2("swift-format", ["format", "--configuration", configPath], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => stdout += d.toString());
+    child.stderr?.on("data", (d) => stderr += d.toString());
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      resolve3({
+        stdout,
+        stderr: stderr + `
+[format] killed after ${timeoutMs}ms`,
+        code: 124
+      });
+    }, timeoutMs);
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve3({ stdout, stderr, code: code ?? 1 });
+    });
+    child.stdin?.write(source);
+    child.stdin?.end();
+  });
+}
+var SWIFT_FORMAT_CONFIG;
+var init_format = __esm({
+  "src/core/format.ts"() {
+    "use strict";
+    SWIFT_FORMAT_CONFIG = {
+      version: 1,
+      lineLength: 100,
+      indentation: { spaces: 4 },
+      tabWidth: 4,
+      maximumBlankLines: 1,
+      respectsExistingLineBreaks: true,
+      lineBreakBeforeControlFlowKeywords: false,
+      lineBreakBeforeEachArgument: false,
+      lineBreakBeforeEachGenericRequirement: false,
+      prioritizeKeepingFunctionOutputTogether: false,
+      indentConditionalCompilationBlocks: true,
+      lineBreakAroundMultilineExpressionChainComponents: false,
+      fileScopedDeclarationPrivacy: { accessLevel: "private" },
+      rules: {
+        AllPublicDeclarationsHaveDocumentation: false,
+        AlwaysUseLowerCamelCase: true,
+        AmbiguousTrailingClosureOverload: true,
+        BeginDocumentationCommentWithOneLineSummary: false,
+        DoNotUseSemicolons: true,
+        DontRepeatTypeInStaticProperties: true,
+        FileScopedDeclarationPrivacy: true,
+        FullyIndirectEnum: true,
+        GroupNumericLiterals: true,
+        IdentifiersMustBeASCII: true,
+        NeverForceUnwrap: false,
+        NeverUseForceTry: false,
+        NeverUseImplicitlyUnwrappedOptionals: false,
+        NoBlockComments: false,
+        NoCasesWithOnlyFallthrough: true,
+        NoEmptyTrailingClosureParentheses: true,
+        NoLabelsInCasePatterns: true,
+        NoLeadingUnderscores: false,
+        NoParensAroundConditions: true,
+        NoVoidReturnOnFunctionSignature: true,
+        OneCasePerLine: true,
+        OneVariableDeclarationPerLine: true,
+        OnlyOneTrailingClosureArgument: true,
+        OrderedImports: true,
+        ReturnVoidInsteadOfEmptyTuple: true,
+        UseEarlyExits: false,
+        UseLetInEveryBoundCaseVariable: true,
+        UseShorthandTypeNames: true,
+        UseSingleLinePropertyGetter: true,
+        UseSynthesizedInitializer: true,
+        UseTripleSlashForDocumentationComments: true,
+        UseWhereClausesInForLoops: false,
+        ValidateDocumentationComments: false
+      }
+    };
+  }
+});
+
+// src/core/sandbox.ts
+var sandbox_exports = {};
+__export(sandbox_exports, {
+  sandboxCompile: () => sandboxCompile,
+  sandboxExists: () => sandboxExists
+});
+import { mkdir as mkdir2, writeFile as writeFile3, rm } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { spawn as spawn3 } from "child_process";
+async function sandboxCompile(swiftSource, options) {
+  const start = Date.now();
+  const available = await hasSwiftToolchain();
+  if (!available) {
+    throw new Error(
+      "Swift toolchain not found. Install Xcode + Command Line Tools, or run without `--sandbox`."
+    );
+  }
+  const root = options.rootDir ?? join3(tmpdir2(), "axint-sandbox", options.intentName);
+  const srcDir = join3(root, "Sources", `${options.intentName}Sandbox`);
+  try {
+    await mkdir2(srcDir, { recursive: true });
+    await writeFile3(join3(root, "Package.swift"), PACKAGE_SWIFT(options.intentName));
+    await writeFile3(join3(srcDir, `${options.intentName}Intent.swift`), swiftSource);
+  } catch (err) {
+    return {
+      ok: false,
+      stdout: "",
+      stderr: `Failed to stage sandbox: ${err.message}`,
+      durationMs: Date.now() - start,
+      sandboxPath: root
+    };
+  }
+  const { stdout, stderr, code } = await runSwiftBuild(root, options.timeoutMs ?? 6e4);
+  if (!options.keep && code === 0) {
+    await rm(root, { recursive: true, force: true }).catch(() => void 0);
+  }
+  return {
+    ok: code === 0,
+    stdout,
+    stderr,
+    durationMs: Date.now() - start,
+    sandboxPath: root
+  };
+}
+async function hasSwiftToolchain() {
+  return new Promise((resolve3) => {
+    const child = spawn3("swift", ["--version"], { stdio: "pipe" });
+    child.on("error", () => resolve3(false));
+    child.on("exit", (code) => resolve3(code === 0));
+  });
+}
+function runSwiftBuild(cwd, timeoutMs) {
+  return new Promise((resolve3) => {
+    const child = spawn3("swift", ["build", "-c", "debug"], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => stdout += d.toString());
+    child.stderr?.on("data", (d) => stderr += d.toString());
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      resolve3({
+        stdout,
+        stderr: stderr + `
+[sandbox] killed after ${timeoutMs}ms`,
+        code: 124
+      });
+    }, timeoutMs);
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve3({ stdout, stderr, code: code ?? 1 });
+    });
+  });
+}
+function sandboxExists(intentName) {
+  return existsSync2(join3(tmpdir2(), "axint-sandbox", intentName));
+}
+var PACKAGE_SWIFT;
+var init_sandbox = __esm({
+  "src/core/sandbox.ts"() {
+    "use strict";
+    PACKAGE_SWIFT = (name) => `// swift-tools-version:5.9
+import PackageDescription
+
+let package = Package(
+  name: "${name}Sandbox",
+  platforms: [
+    .iOS(.v16),
+    .macOS(.v13),
+  ],
+  products: [
+    .library(name: "${name}Sandbox", targets: ["${name}Sandbox"]),
+  ],
+  targets: [
+    .target(
+      name: "${name}Sandbox",
+      path: "Sources/${name}Sandbox"
+    ),
+  ]
+)
+`;
+  }
+});
+
+// src/mcp/scaffold.ts
+function scaffoldIntent(input) {
+  const name = toPascalCase2(input.name);
+  const title = humanize(name);
+  const desc = sanitize(input.description);
+  const domain = input.domain ? sanitize(input.domain) : void 0;
+  const paramLines = [];
+  const destructureNames = [];
+  for (const p of input.params ?? []) {
+    const type = resolveType(p.type);
+    const safeName = toCamelCase(p.name);
+    destructureNames.push(safeName);
+    paramLines.push(
+      `    ${safeName}: param.${type}(${JSON.stringify(sanitize(p.description))}),`
+    );
+  }
+  const paramsBlock = paramLines.length > 0 ? `
+${paramLines.join("\n")}
+  ` : "";
+  const destructure = destructureNames.length > 0 ? `{ ${destructureNames.join(", ")} }` : "_";
+  const lines = [];
+  lines.push(`/**`);
+  lines.push(` * ${name}Intent`);
+  lines.push(` *`);
+  lines.push(` * ${desc}`);
+  lines.push(` *`);
+  lines.push(` * Generated by axint_scaffold. Edit freely, then run:`);
+  lines.push(` *   npx axint compile src/intents/${kebab(name)}.ts`);
+  lines.push(` */`);
+  lines.push(`import { defineIntent, param } from "@axintai/compiler";`);
+  lines.push(``);
+  lines.push(`export default defineIntent({`);
+  lines.push(`  name: ${JSON.stringify(name)},`);
+  lines.push(`  title: ${JSON.stringify(title)},`);
+  lines.push(`  description: ${JSON.stringify(desc)},`);
+  if (domain) lines.push(`  domain: ${JSON.stringify(domain)},`);
+  lines.push(`  params: {${paramsBlock}},`);
+  lines.push(`  perform: async (${destructure}) => {`);
+  lines.push(`    // TODO: Implement ${name}`);
+  lines.push(`    return { success: true };`);
+  lines.push(`  },`);
+  lines.push(`});`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function resolveType(raw) {
+  const lc = raw.toLowerCase();
+  if (PARAM_TYPES.has(lc)) return lc;
+  if (lc in LEGACY_PARAM_ALIASES) return LEGACY_PARAM_ALIASES[lc];
+  return "string";
+}
+function toPascalCase2(s) {
+  if (!s) return "UnnamedIntent";
+  return s.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (c) => c.toUpperCase());
+}
+function toCamelCase(s) {
+  const pascal = toPascalCase2(s);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function humanize(pascal) {
+  return pascal.replace(/([A-Z])/g, " $1").trim();
+}
+function kebab(pascal) {
+  return pascal.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/\s+/g, "-").toLowerCase();
+}
+function sanitize(s) {
+  return s.replace(/[\x00-\x1f\x7f]+/g, " ").replace(/\s+/g, " ").trim();
+}
+var init_scaffold = __esm({
+  "src/mcp/scaffold.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// src/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startMCPServer: () => startMCPServer
+});
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+async function startMCPServer() {
+  const server = new Server(
+    { name: "axint", version: pkg.version },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "axint_scaffold",
+        description: "Generate a starter TypeScript intent file using the axint SDK. Pass a PascalCase name, a description, and optionally a domain (messaging, productivity, health, finance, commerce, media, navigation, smart-home) and a list of parameters. Returns ready-to-save source code that compiles with `axint compile`.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "PascalCase name for the intent, e.g., 'CreateEvent'"
+            },
+            description: {
+              type: "string",
+              description: "Human-readable description of what the intent does"
+            },
+            domain: {
+              type: "string",
+              description: "Optional Apple App Intent domain (messaging, productivity, health, finance, commerce, media, navigation, smart-home)"
+            },
+            params: {
+              type: "array",
+              description: "Optional initial parameters. Each item: { name, type, description }. Supported types: string, int, double, float, boolean, date, duration, url.",
+              items: {
+                type: "object",
+                properties: {
+                  name: { type: "string" },
+                  type: { type: "string" },
+                  description: { type: "string" }
+                },
+                required: ["name", "type", "description"]
+              }
+            }
+          },
+          required: ["name", "description"]
+        }
+      },
+      {
+        name: "axint_compile",
+        description: "Compile a TypeScript intent definition into a native Swift App Intent. Optionally emits Info.plist and entitlements fragments alongside the Swift file. Pass the full TypeScript source code using the defineIntent() API.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            source: {
+              type: "string",
+              description: "TypeScript source code containing a defineIntent() call"
+            },
+            fileName: {
+              type: "string",
+              description: "Optional file name for error messages"
+            },
+            emitInfoPlist: {
+              type: "boolean",
+              description: "When true, also returns an Info.plist XML fragment for the intent's declared infoPlistKeys"
+            },
+            emitEntitlements: {
+              type: "boolean",
+              description: "When true, also returns an .entitlements XML fragment for the intent's declared entitlements"
+            }
+          },
+          required: ["source"]
+        }
+      },
+      {
+        name: "axint_validate",
+        description: "Validate a TypeScript intent definition without generating Swift output. Returns diagnostics with error codes and fix suggestions.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            source: {
+              type: "string",
+              description: "TypeScript source code containing a defineIntent() call"
+            }
+          },
+          required: ["source"]
+        }
+      },
+      {
+        name: "axint_list_templates",
+        description: "List the bundled reference templates. Use `axint_template` to fetch the full source of a specific template by id.",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "axint_template",
+        description: "Return the full TypeScript source code of a bundled reference template by id. Use `axint_list_templates` to discover valid ids.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Template id (e.g., 'send-message', 'create-event')"
+            }
+          },
+          required: ["id"]
+        }
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      if (name === "axint_scaffold") {
+        const a = args;
+        const source = scaffoldIntent({
+          name: a.name,
+          description: a.description,
+          domain: a.domain,
+          params: a.params
+        });
+        return { content: [{ type: "text", text: source }] };
+      }
+      if (name === "axint_compile") {
+        const a = args;
+        const result = compileSource(a.source, a.fileName || "<mcp>", {
+          emitInfoPlist: a.emitInfoPlist,
+          emitEntitlements: a.emitEntitlements
+        });
+        if (result.success && result.output) {
+          const parts = [
+            "// \u2500\u2500\u2500 Swift \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+            result.output.swiftCode
+          ];
+          if (result.output.infoPlistFragment) {
+            parts.push("// \u2500\u2500\u2500 Info.plist fragment \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+            parts.push(result.output.infoPlistFragment);
+          }
+          if (result.output.entitlementsFragment) {
+            parts.push("// \u2500\u2500\u2500 .entitlements fragment \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+            parts.push(result.output.entitlementsFragment);
+          }
+          return {
+            content: [{ type: "text", text: parts.join("\n") }]
+          };
+        }
+        const errorText = result.diagnostics.map((d) => `[${d.code}] ${d.severity}: ${d.message}`).join("\n");
+        return {
+          content: [{ type: "text", text: errorText }],
+          isError: true
+        };
+      }
+      if (name === "axint_validate") {
+        const a = args;
+        const result = compileSource(a.source, "<validate>");
+        const text = result.diagnostics.length > 0 ? result.diagnostics.map((d) => `[${d.code}] ${d.severity}: ${d.message}`).join("\n") : "Valid intent definition. No issues found.";
+        return { content: [{ type: "text", text }] };
+      }
+      if (name === "axint_list_templates") {
+        const list = TEMPLATES.map(
+          (t) => `${t.id}  \u2014  ${t.title}${t.domain ? ` [${t.domain}]` : ""}`
+        ).join("\n");
+        return {
+          content: [
+            {
+              type: "text",
+              text: list || "No templates registered."
+            }
+          ]
+        };
+      }
+      if (name === "axint_template") {
+        const a = args;
+        const tpl = getTemplate(a.id);
+        if (!tpl) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Unknown template id: ${a.id}. Use axint_list_templates to see available ids.`
+              }
+            ],
+            isError: true
+          };
+        }
+        return { content: [{ type: "text", text: tpl.source }] };
+      }
+      return {
+        content: [{ type: "text", text: `Unknown tool: ${name}` }],
+        isError: true
+      };
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Tool error: ${err instanceof Error ? err.message : String(err)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+var __dirname, pkg;
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    "use strict";
+    init_compiler();
+    init_scaffold();
+    init_templates();
+    __dirname = dirname(fileURLToPath(import.meta.url));
+    pkg = JSON.parse(
+      readFileSync2(resolve(__dirname, "../../package.json"), "utf-8")
+    );
+  }
+});
+
+// src/cli/index.ts
+init_compiler();
+import { Command } from "commander";
+import {
+  readFileSync as readFileSync3,
+  writeFileSync,
+  mkdirSync,
+  existsSync as existsSync3,
+  watch as fsWatch,
+  statSync
+} from "fs";
+import { resolve as resolve2, dirname as dirname2, basename } from "path";
+import { spawn as spawn4 } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/core/eject.ts
+init_compiler();
+function ejectIntent(source, fileName, options = {}) {
+  const compileResult = compileSource(source, fileName, {
+    validate: true,
+    emitInfoPlist: true,
+    emitEntitlements: true
+  });
+  if (!compileResult.success || !compileResult.output) {
+    throw new Error(
+      `Compilation failed: ${compileResult.diagnostics.filter((d) => d.severity === "error").map((d) => d.message).join("; ")}`
+    );
+  }
+  const { ir, swiftCode, infoPlistFragment, entitlementsFragment } = compileResult.output;
+  const outDir = options.outDir ?? ".";
+  const ejectedSwift = transformSwiftForEject(swiftCode, ir);
+  const intentFileName = `${ir.name}Intent.swift`;
+  const swiftPath = `${outDir}/${intentFileName}`;
+  const plistPath = infoPlistFragment ? `${outDir}/${ir.name}Intent.plist.fragment.xml` : null;
+  const entitlementsPath = entitlementsFragment ? `${outDir}/${ir.name}Intent.entitlements.fragment.xml` : null;
+  const testPath = options.includeTests ? `${outDir}/${ir.name}IntentTests.swift` : null;
+  const result = {
+    swiftFile: {
+      path: swiftPath,
+      content: ejectedSwift
+    }
+  };
+  if (infoPlistFragment && plistPath) {
+    result.infoPlist = {
+      path: plistPath,
+      content: infoPlistFragment
+    };
+  }
+  if (entitlementsFragment && entitlementsPath) {
+    result.entitlements = {
+      path: entitlementsPath,
+      content: entitlementsFragment
+    };
+  }
+  if (options.includeTests && testPath) {
+    result.testFile = {
+      path: testPath,
+      content: generateTestFile(ir)
+    };
+  }
+  return result;
+}
+function transformSwiftForEject(swiftCode, ir) {
+  const lines = swiftCode.split("\n");
+  const result = [];
+  let inHeader = true;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (inHeader && line.startsWith("// ")) {
+      if (i === 0) {
+        result.push(`// ${ir.name}Intent.swift`);
+      } else if (line.includes("Generated by Axint")) {
+        result.push(
+          `// Originally generated by Axint (https://github.com/agenticempire/axint)`
+        );
+      } else if (line.includes("Do not edit manually")) {
+      } else {
+        result.push(line);
+      }
+    } else if (line === "") {
+      inHeader = false;
+      result.push(line);
+    } else {
+      inHeader = false;
+      if (line.includes("// TODO: Implement your intent logic here.")) {
+        result.push(`        // TODO: Implement your intent logic here.`);
+        result.push(`        //`);
+        result.push(
+          `        // For more information about App Intents, see:`
+        );
+        result.push(
+          `        // https://developer.apple.com/documentation/appintents`
+        );
+      } else {
+        result.push(line);
+      }
+    }
+  }
+  return result.join("\n");
+}
+function generateTestFile(ir) {
+  const lines = [];
+  lines.push(`// ${ir.name}IntentTests.swift`);
+  lines.push(`// Ejected from Axint`);
+  lines.push(``);
+  lines.push(`import XCTest`);
+  lines.push(`import AppIntents`);
+  lines.push(``);
+  lines.push(`final class ${ir.name}IntentTests: XCTestCase {`);
+  lines.push(``);
+  lines.push(`    func testIntentInitialization() throws {`);
+  lines.push(`        let intent = ${ir.name}Intent()`);
+  lines.push(`        XCTAssertEqual(${ir.name}Intent.title.stringValue, "${ir.title}")`);
+  lines.push(`    }`);
+  lines.push(``);
+  lines.push(`    func testIntentPerform() async throws {`);
+  lines.push(`        let intent = ${ir.name}Intent()`);
+  lines.push(`        // TODO: Set up intent parameters and test perform()`);
+  lines.push(`        // let result = try await intent.perform()`);
+  lines.push(`        // XCTAssertNotNil(result)`);
+  lines.push(`    }`);
+  lines.push(``);
+  lines.push(`}`);
+  lines.push(``);
+  return lines.join("\n");
+}
+
+// src/cli/scaffold.ts
+init_templates();
+import { mkdir, writeFile, readdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join, relative } from "path";
+import { spawn } from "child_process";
+async function scaffoldProject(opts) {
+  const { targetDir, projectName, template, version, install } = opts;
+  const tpl = getTemplate(template);
+  if (!tpl) {
+    throw new Error(
+      `Unknown template "${template}". Run \`axint templates\` to see available templates.`
+    );
+  }
+  if (existsSync(targetDir)) {
+    const entries = await readdir(targetDir).catch(() => []);
+    const populated = entries.filter((e) => !e.startsWith(".git") && e !== ".DS_Store");
+    if (populated.length > 0) {
+      throw new Error(
+        `Directory "${targetDir}" is not empty. Pick an empty folder or use \`axint init my-new-app\`.`
+      );
+    }
+  } else {
+    await mkdir(targetDir, { recursive: true });
+  }
+  const files = [];
+  const write = async (rel, content) => {
+    const abs = join(targetDir, rel);
+    await mkdir(join(abs, "..").replace(/[/\\][^/\\]+$/, ""), { recursive: true }).catch(
+      () => void 0
+    );
+    const parent = abs.substring(
+      0,
+      abs.lastIndexOf("/") === -1 ? abs.lastIndexOf("\\") : abs.lastIndexOf("/")
+    );
+    if (parent && parent !== abs) {
+      await mkdir(parent, { recursive: true }).catch(() => void 0);
+    }
+    await writeFile(abs, content, "utf-8");
+    files.push(relative(targetDir, abs));
+  };
+  await write(
+    "package.json",
+    JSON.stringify(
+      {
+        name: projectName,
+        version: "0.0.1",
+        private: true,
+        type: "module",
+        scripts: {
+          compile: `axint compile intents/${template}.ts --out ios/Intents/`,
+          "compile:plist": `axint compile intents/${template}.ts --out ios/Intents/ --emit-info-plist --emit-entitlements`,
+          validate: `axint validate intents/${template}.ts`,
+          sandbox: `axint validate intents/${template}.ts --sandbox`
+        },
+        dependencies: {
+          "@axintai/compiler": `^${version}`
+        }
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  await write(
+    "tsconfig.json",
+    JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          module: "NodeNext",
+          moduleResolution: "NodeNext",
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          noEmit: true,
+          isolatedModules: true,
+          verbatimModuleSyntax: false,
+          resolveJsonModule: true
+        },
+        include: ["intents/**/*.ts"]
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  await write(
+    ".gitignore",
+    ["node_modules", "dist", ".DS_Store", ".axint-sandbox", "*.log", ""].join("\n")
+  );
+  await write(`intents/${template}.ts`, tpl.source);
+  await write(
+    ".vscode/mcp.json",
+    JSON.stringify(
+      {
+        mcpServers: {
+          axint: {
+            command: "npx",
+            args: ["-y", "@axintai/compiler", "axint-mcp"]
+          }
+        }
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  await write("README.md", scaffoldReadme(projectName, template, tpl.title, version));
+  await mkdir(join(targetDir, "ios", "Intents"), { recursive: true });
+  await write("ios/Intents/.gitkeep", "");
+  if (install) {
+    await runNpmInstall(targetDir);
+  }
+  return {
+    files,
+    entryFile: `${template}.ts`
+  };
+}
+function scaffoldReadme(name, template, title, version) {
+  return `# ${name}
+
+An [Axint](https://axint.ai) project \u2014 write App Intents in TypeScript, ship them to Siri.
+
+Generated from the **${title}** template, pinned to \`@axintai/compiler@^${version}\`.
+
+## Compile it
+
+\`\`\`bash
+npm install
+npm run compile
+\`\`\`
+
+Output lands in \`ios/Intents/\`. Drag that folder into your Xcode target and you're done.
+
+## Validate it
+
+\`\`\`bash
+npm run validate              # fast IR + Swift lint
+npm run sandbox               # stage 4: swift build in an SPM sandbox (macOS only)
+\`\`\`
+
+## Use with AI coding tools
+
+The \`.vscode/mcp.json\` file is pre-wired for Cursor, Claude Code, and Windsurf.
+Any agent that supports MCP can now call \`axint_compile\`, \`axint_validate\`,
+\`axint_scaffold\`, and \`axint_template\` against this project.
+
+## Next
+
+- Edit \`intents/${template}.ts\` \u2014 this is your App Intent source of truth.
+- Add more intents in the \`intents/\` folder.
+- Run \`axint templates\` to see every bundled starter.
+- Read the docs at https://github.com/agenticempire/axint#readme
+
+---
+
+_Generated by \`axint init\`_
+`;
+}
+function runNpmInstall(cwd) {
+  return new Promise((resolve3, reject) => {
+    const child = spawn("npm", ["install"], { cwd, stdio: "inherit" });
+    child.on("exit", (code) => {
+      if (code === 0) resolve3();
+      else reject(new Error(`npm install exited with code ${code}`));
+    });
+    child.on("error", reject);
+  });
+}
+
+// src/cli/index.ts
+init_templates();
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var pkg2 = JSON.parse(readFileSync3(resolve2(__dirname2, "../../package.json"), "utf-8"));
+var VERSION = pkg2.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("init").description("Scaffold a new Axint project (zero-config, ready to compile)").argument("[dir]", "Project directory (defaults to current dir)", ".").option(
+  "-t, --template <name>",
+  "Starter template (send-message, create-event, book-ride, ...)",
+  "create-event"
+).option("--no-install", "Skip running `npm install`").option("--name <name>", "Project name (defaults to the directory name)").action(
+  async (dir, options) => {
+    const targetDir = resolve2(dir);
+    const projectName = options.name ?? basename(targetDir);
+    try {
+      const result = await scaffoldProject({
+        targetDir,
+        projectName,
+        template: options.template,
+        version: VERSION,
+        install: options.install
+      });
+      console.log();
+      console.log(`  \x1B[38;5;208m\u25C6\x1B[0m \x1B[1mAxint\x1B[0m \xB7 project ready`);
+      console.log();
+      console.log(
+        `    \x1B[2m${result.files.length} files written to ${targetDir}\x1B[0m`
+      );
+      console.log();
+      console.log(`  \x1B[1mNext:\x1B[0m`);
+      if (dir !== ".") console.log(`    cd ${dir}`);
+      if (options.install) {
+        console.log(
+          `    npx axint compile intents/${result.entryFile} --out ios/Intents/`
+        );
+      } else {
+        console.log(`    npm install`);
+        console.log(
+          `    npx axint compile intents/${result.entryFile} --out ios/Intents/`
+        );
+      }
+      console.log();
+      console.log(
+        `  \x1B[2mDocs:   https://github.com/agenticempire/axint#readme\x1B[0m`
+      );
+      console.log(
+        `  \x1B[2mMCP:    npx axint-mcp (add to Claude Code, Cursor, Windsurf)\x1B[0m`
+      );
+      console.log();
+    } catch (err) {
+      console.error(`\x1B[31merror:\x1B[0m ${err.message ?? err}`);
+      process.exit(1);
+    }
+  }
+);
+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)").option(
+  "--emit-info-plist",
+  "Emit a <Name>.plist.fragment.xml with NSAppIntentsDomains next to the Swift file"
+).option(
+  "--emit-entitlements",
+  "Emit a <Name>.entitlements.fragment.xml next to the Swift file"
+).option(
+  "--sandbox",
+  "Run stage 4 validation: swift build in an SPM sandbox (macOS only)"
+).option(
+  "--format",
+  "Pipe generated Swift through swift-format with the Axint house style (macOS/Linux if swift-format is on $PATH)"
+).option(
+  "--strict-format",
+  "Fail the build if swift-format is missing or errors (implies --format)"
+).option(
+  "--from-ir",
+  "Treat <file> as IR JSON (from Python SDK or any language) instead of TypeScript. Use - to read from stdin."
+).action(
+  async (file, options) => {
+    const filePath = resolve2(file);
+    try {
+      let result;
+      if (options.fromIr) {
+        let irRaw;
+        if (file === "-") {
+          const chunks = [];
+          for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+          }
+          irRaw = Buffer.concat(chunks).toString("utf-8");
+        } else {
+          irRaw = readFileSync3(filePath, "utf-8");
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(irRaw);
+        } catch {
+          console.error(`\x1B[31merror:\x1B[0m Invalid JSON in ${file}`);
+          process.exit(1);
+        }
+        const irData = Array.isArray(parsed) ? parsed[0] : parsed;
+        if (!irData || typeof irData !== "object") {
+          console.error(
+            `\x1B[31merror:\x1B[0m Expected an IR object or array in ${file}`
+          );
+          process.exit(1);
+        }
+        const ir = irFromJSON(irData);
+        result = compileFromIR(ir, {
+          outDir: options.out,
+          validate: options.validate,
+          emitInfoPlist: options.emitInfoPlist,
+          emitEntitlements: options.emitEntitlements
+        });
+      } else {
+        result = compileFile(filePath, {
+          outDir: options.out,
+          validate: options.validate,
+          emitInfoPlist: options.emitInfoPlist,
+          emitEntitlements: options.emitEntitlements
+        });
+      }
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              success: result.success,
+              swift: result.output?.swiftCode ?? null,
+              outputPath: result.output?.outputPath ?? null,
+              infoPlistFragment: result.output?.infoPlistFragment ?? null,
+              entitlementsFragment: result.output?.entitlementsFragment ?? 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.format || options.strictFormat) {
+        try {
+          const { formatSwift: formatSwift2 } = await Promise.resolve().then(() => (init_format(), format_exports));
+          const fmt = await formatSwift2(result.output.swiftCode, {
+            strict: options.strictFormat
+          });
+          if (fmt.ran) {
+            result.output.swiftCode = fmt.formatted;
+          } else if (!options.json) {
+            console.error(
+              `\x1B[33mwarning:\x1B[0m swift-format skipped \u2014 ${fmt.reason}`
+            );
+          }
+        } catch (fmtErr) {
+          if (options.strictFormat) {
+            console.error(`\x1B[31merror:\x1B[0m ${fmtErr.message}`);
+            process.exit(1);
+          }
+          console.error(
+            `\x1B[33mwarning:\x1B[0m swift-format skipped \u2014 ${fmtErr.message}`
+          );
+        }
+      }
+      if (options.stdout) {
+        console.log(result.output.swiftCode);
+      } else {
+        const outPath = resolve2(result.output.outputPath);
+        mkdirSync(dirname2(outPath), { recursive: true });
+        writeFileSync(outPath, result.output.swiftCode, "utf-8");
+        console.log(`\x1B[32m\u2713\x1B[0m Compiled ${result.output.ir.name} \u2192 ${outPath}`);
+        if (options.emitInfoPlist && result.output.infoPlistFragment) {
+          const plistPath = outPath.replace(/\.swift$/, ".plist.fragment.xml");
+          writeFileSync(plistPath, result.output.infoPlistFragment, "utf-8");
+          console.log(`\x1B[32m\u2713\x1B[0m Info.plist fragment \u2192 ${plistPath}`);
+        }
+        if (options.emitEntitlements && result.output.entitlementsFragment) {
+          const entPath = outPath.replace(/\.swift$/, ".entitlements.fragment.xml");
+          writeFileSync(entPath, result.output.entitlementsFragment, "utf-8");
+          console.log(`\x1B[32m\u2713\x1B[0m Entitlements fragment \u2192 ${entPath}`);
+        }
+      }
+      if (options.sandbox && !options.stdout) {
+        try {
+          const { sandboxCompile: sandboxCompile2 } = await Promise.resolve().then(() => (init_sandbox(), sandbox_exports));
+          console.log();
+          console.log(`\x1B[36m\u2192\x1B[0m Stage 4: SPM sandbox compile...`);
+          const sandboxResult = await sandboxCompile2(result.output.swiftCode, {
+            intentName: result.output.ir.name
+          });
+          if (sandboxResult.ok) {
+            console.log(
+              `\x1B[32m\u2713\x1B[0m Swift builds cleanly (${sandboxResult.durationMs}ms in ${sandboxResult.sandboxPath})`
+            );
+          } else {
+            console.error(
+              `\x1B[31m\u2717\x1B[0m Sandbox compile failed:
+${sandboxResult.stderr}`
+            );
+            process.exit(1);
+          }
+        } catch (sbErr) {
+          console.error(
+            `\x1B[33mwarning:\x1B[0m sandbox compile skipped \u2014 ${sbErr.message}`
+          );
+        }
+      }
+      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").option(
+  "--sandbox",
+  "Run stage 4 validation: swift build in an SPM sandbox (macOS only)"
+).action(async (file, options) => {
+  const filePath = resolve2(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) {
+      process.exit(1);
+    }
+    if (options.sandbox && result.output) {
+      const { sandboxCompile: sandboxCompile2 } = await Promise.resolve().then(() => (init_sandbox(), sandbox_exports));
+      console.log(`\x1B[36m\u2192\x1B[0m Stage 4: SPM sandbox compile...`);
+      const sandboxResult = await sandboxCompile2(result.output.swiftCode, {
+        intentName: result.output.ir.name
+      });
+      if (!sandboxResult.ok) {
+        console.error(`\x1B[31m\u2717\x1B[0m ${sandboxResult.stderr}`);
+        process.exit(1);
+      }
+      console.log(
+        `\x1B[32m\u2713\x1B[0m Valid intent definition (sandbox-verified, ${sandboxResult.durationMs}ms)`
+      );
+    } else {
+      console.log(`\x1B[32m\u2713\x1B[0m Valid intent definition`);
+    }
+  } 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("eject").description("Eject an intent to standalone Swift with no Axint dependency").argument("<file>", "Path to the TypeScript intent definition").option("-o, --out <dir>", "Output directory for ejected files", ".").option("--include-tests", "Generate a basic XCTest file alongside the Swift").option(
+  "--format",
+  "Pipe generated Swift through swift-format with the Axint house style (macOS/Linux if swift-format is on $PATH)"
+).action(
+  async (file, options) => {
+    const filePath = resolve2(file);
+    try {
+      let source;
+      try {
+        source = readFileSync3(filePath, "utf-8");
+      } catch (_err) {
+        console.error(`\x1B[31merror:\x1B[0m Cannot read file: ${filePath}`);
+        process.exit(1);
+      }
+      const result = ejectIntent(source, basename(filePath), {
+        outDir: options.out,
+        includeTests: options.includeTests,
+        format: options.format
+      });
+      const filesWritten = [];
+      mkdirSync(dirname2(result.swiftFile.path), { recursive: true });
+      writeFileSync(result.swiftFile.path, result.swiftFile.content, "utf-8");
+      filesWritten.push("Swift");
+      if (result.infoPlist) {
+        writeFileSync(result.infoPlist.path, result.infoPlist.content, "utf-8");
+        filesWritten.push("Info.plist fragment");
+      }
+      if (result.entitlements) {
+        writeFileSync(result.entitlements.path, result.entitlements.content, "utf-8");
+        filesWritten.push("entitlements fragment");
+      }
+      if (result.testFile) {
+        writeFileSync(result.testFile.path, result.testFile.content, "utf-8");
+        filesWritten.push("XCTest file");
+      }
+      console.log();
+      console.log(
+        `\x1B[32m\u2713\x1B[0m Ejected \u2192 ${filesWritten.length} file(s) (${filesWritten.join(", ")})`
+      );
+      console.log();
+      console.log(`  \x1B[1mOutput directory:\x1B[0m ${resolve2(options.out)}`);
+      console.log();
+      console.log(`  These files are now standalone and have no Axint dependency.`);
+      console.log(
+        `  You can commit them to version control and use them in your project.`
+      );
+      console.log();
+    } 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.message ?? err}`);
+      }
+      process.exit(1);
+    }
+  }
+);
+program.command("templates").description("List bundled intent templates").argument("[name]", "Template name to print (omit to list all)").option("--json", "Output as JSON").action((name, options) => {
+  if (!name) {
+    const list = listTemplates();
+    if (options.json) {
+      console.log(JSON.stringify(list, null, 2));
+      return;
+    }
+    console.log(`  \x1B[1mBundled templates\x1B[0m (${list.length})`);
+    console.log();
+    for (const t of list) {
+      console.log(
+        `    \x1B[38;5;208m\u25C6\x1B[0m ${t.name}  \x1B[2m\u2014 ${t.description}\x1B[0m`
+      );
+    }
+    console.log();
+    console.log(
+      `  \x1B[2mUse:  axint templates <name>  or  axint init -t <name>\x1B[0m`
+    );
+    return;
+  }
+  const tpl = getTemplate(name);
+  if (!tpl) {
+    console.error(`\x1B[31merror:\x1B[0m template "${name}" not found`);
+    process.exit(1);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(tpl, null, 2));
+    return;
+  }
+  console.log(tpl.source);
+});
+program.command("login").description("Authenticate with the Axint Registry via GitHub").action(async () => {
+  const { homedir } = await import("os");
+  const { join: join4 } = await import("path");
+  const { spawn: spawn5 } = await import("child_process");
+  const configDir = join4(homedir(), ".axint");
+  const credPath = join4(configDir, "credentials.json");
+  const registryUrl = process.env.AXINT_REGISTRY_URL ?? "https://registry.axint.ai";
+  console.log();
+  console.log(`  \x1B[38;5;208m\u25C6\x1B[0m \x1B[1mAxint\x1B[0m \xB7 login`);
+  console.log();
+  try {
+    const res = await fetch(`${registryUrl}/api/v1/auth/device-code`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ client_id: "axint-cli" })
+    });
+    if (!res.ok) {
+      console.error(
+        `\x1B[31merror:\x1B[0m Failed to start login flow (HTTP ${res.status})`
+      );
+      process.exit(1);
+    }
+    const { device_code, user_code, verification_uri, interval } = await res.json();
+    console.log(`  Open this URL in your browser:`);
+    console.log();
+    console.log(`    \x1B[1;4m${verification_uri}\x1B[0m`);
+    console.log();
+    console.log(`  And enter this code: \x1B[1;38;5;208m${user_code}\x1B[0m`);
+    console.log();
+    console.log(`  \x1B[2mWaiting for authorization\u2026\x1B[0m`);
+    try {
+      const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      spawn5(openCmd, [verification_uri], { stdio: "ignore", detached: true }).unref();
+    } catch {
+    }
+    const pollInterval = (interval ?? 5) * 1e3;
+    let token = null;
+    for (let i = 0; i < 60; i++) {
+      await new Promise((r) => setTimeout(r, pollInterval));
+      const pollRes = await fetch(`${registryUrl}/api/v1/auth/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ device_code, grant_type: "device_code" })
+      });
+      if (pollRes.ok) {
+        const data = await pollRes.json();
+        token = data.access_token;
+        break;
+      }
+      const err = await pollRes.json();
+      if (err.error === "authorization_pending") continue;
+      if (err.error === "slow_down") {
+        await new Promise((r) => setTimeout(r, 5e3));
+        continue;
+      }
+      if (err.error === "expired_token") {
+        console.error(
+          `\x1B[31merror:\x1B[0m Login timed out. Run \`axint login\` again.`
+        );
+        process.exit(1);
+      }
+      console.error(`\x1B[31merror:\x1B[0m ${err.error ?? "Unknown error"}`);
+      process.exit(1);
+    }
+    if (!token) {
+      console.error(`\x1B[31merror:\x1B[0m Login timed out after 5 minutes.`);
+      process.exit(1);
+    }
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(
+      credPath,
+      JSON.stringify({ access_token: token, registry: registryUrl }, null, 2),
+      "utf-8"
+    );
+    console.log(
+      `  \x1B[32m\u2713\x1B[0m Logged in! Credentials saved to \x1B[2m${credPath}\x1B[0m`
+    );
+    console.log();
+  } catch (err) {
+    console.error(`\x1B[31merror:\x1B[0m ${err.message ?? err}`);
+    process.exit(1);
+  }
+});
+program.command("publish").description("Publish an intent to the Axint Registry").option("--dry-run", "Validate and show what would be published without uploading").option("--tag <tags...>", "Override tags").action(async (options) => {
+  const cwd = process.cwd();
+  const configPath = resolve2(cwd, "axint.json");
+  console.log();
+  console.log(`  \x1B[38;5;208m\u25C6\x1B[0m \x1B[1mAxint\x1B[0m \xB7 publish`);
+  console.log();
+  if (!existsSync3(configPath)) {
+    console.error(`  \x1B[31merror:\x1B[0m No axint.json found in ${cwd}`);
+    console.error(`  \x1B[2mRun \`axint init\` to create one.\x1B[0m`);
+    process.exit(1);
+  }
+  let config;
+  try {
+    config = JSON.parse(readFileSync3(configPath, "utf-8"));
+  } catch {
+    console.error(`  \x1B[31merror:\x1B[0m Failed to parse axint.json`);
+    process.exit(1);
+  }
+  const entryFile = config.entry ?? "intent.ts";
+  const entryPath = resolve2(cwd, entryFile);
+  if (!existsSync3(entryPath)) {
+    console.error(`  \x1B[31merror:\x1B[0m Entry file not found: ${entryFile}`);
+    process.exit(1);
+  }
+  console.log(`  \x1B[2m\u23FA\x1B[0m Compiling ${entryFile}\u2026`);
+  let result;
+  try {
+    result = await compileFile(entryPath, {});
+  } catch (err) {
+    console.error(`  \x1B[31m\u2717\x1B[0m Compilation failed: ${err.message}`);
+    process.exit(1);
+  }
+  if (!result.success || !result.output) {
+    console.error(`  \x1B[31m\u2717\x1B[0m Compilation failed`);
+    for (const d of result.diagnostics) {
+      console.error(`    [${d.code}] ${d.message}`);
+    }
+    process.exit(1);
+  }
+  console.log(
+    `  \x1B[32m\u2713\x1B[0m Compiled \u2192 ${result.output.swiftCode.split("\n").length} lines of Swift`
+  );
+  let readme;
+  const readmePath = resolve2(cwd, config.readme ?? "README.md");
+  if (existsSync3(readmePath)) {
+    readme = readFileSync3(readmePath, "utf-8");
+  }
+  let pySource;
+  const pyPath = resolve2(cwd, entryFile.replace(/\.ts$/, ".py"));
+  if (existsSync3(pyPath)) {
+    pySource = readFileSync3(pyPath, "utf-8");
+  }
+  const tags = options.tag ?? config.tags ?? [];
+  const namespace = config.namespace.startsWith("@") ? config.namespace : `@${config.namespace}`;
+  const payload = {
+    namespace,
+    slug: config.slug,
+    name: config.name,
+    version: config.version,
+    description: config.description,
+    readme,
+    primary_language: config.primary_language ?? (pySource ? "both" : "typescript"),
+    surface_areas: config.surface_areas ?? [],
+    tags,
+    license: config.license ?? "Apache-2.0",
+    homepage: config.homepage,
+    repository: config.repository,
+    ts_source: readFileSync3(entryPath, "utf-8"),
+    py_source: pySource,
+    swift_output: result.output.swiftCode,
+    plist_fragment: result.output.infoPlistFragment ?? null,
+    ir: result.output.ir ?? {},
+    compiler_version: VERSION
+  };
+  if (options.dryRun) {
+    console.log(`  \x1B[32m\u2713\x1B[0m Validation passed`);
+    console.log();
+    console.log(
+      `  Would publish: \x1B[1m${namespace}/${config.slug}@${config.version}\x1B[0m`
+    );
+    console.log(
+      `  Bundle size:   ${Buffer.from(JSON.stringify(payload)).byteLength} bytes`
+    );
+    console.log(`  Tags:          ${tags.join(", ") || "(none)"}`);
+    console.log();
+    return;
+  }
+  const { homedir } = await import("os");
+  const { join: join4 } = await import("path");
+  const credPath = join4(homedir(), ".axint", "credentials.json");
+  if (!existsSync3(credPath)) {
+    console.error(`  \x1B[31merror:\x1B[0m Not logged in. Run \`axint login\` first.`);
+    process.exit(1);
+  }
+  let creds;
+  try {
+    creds = JSON.parse(readFileSync3(credPath, "utf-8"));
+  } catch {
+    console.error(
+      `  \x1B[31merror:\x1B[0m Corrupt credentials file. Run \`axint login\` again.`
+    );
+    process.exit(1);
+  }
+  const registryUrl = creds.registry ?? "https://registry.axint.ai";
+  console.log(`  \x1B[2m\u23FA\x1B[0m Publishing to ${registryUrl}\u2026`);
+  try {
+    const res = await fetch(`${registryUrl}/api/v1/publish`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${creds.access_token}`,
+        "X-Axint-Version": VERSION
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ detail: res.statusText }));
+      console.error(
+        `  \x1B[31m\u2717\x1B[0m ${err.title ?? "Publish failed"}: ${err.detail ?? res.statusText}`
+      );
+      process.exit(1);
+    }
+    const data = await res.json();
+    console.log(`  \x1B[32m\u2713\x1B[0m Published!`);
+    console.log();
+    console.log(`    ${data.url}`);
+    console.log();
+    console.log(`  \x1B[2mInstall: axint add ${namespace}/${config.slug}\x1B[0m`);
+    console.log();
+  } catch (err) {
+    console.error(`  \x1B[31merror:\x1B[0m ${err.message ?? err}`);
+    process.exit(1);
+  }
+});
+program.command("add").description("Install a template from the Axint Registry").argument(
+  "<package>",
+  "Template to install (e.g., @axintai/create-event or @axintai/create-event@1.0.0)"
+).option("--to <dir>", "Target directory", "intents").action(async (pkg3, options) => {
+  console.log();
+  console.log(`  \x1B[38;5;208m\u25C6\x1B[0m \x1B[1mAxint\x1B[0m \xB7 add`);
+  console.log();
+  const match = pkg3.match(/^(@[a-z0-9][a-z0-9-]*)\/([a-z0-9][a-z0-9-]*)(?:@(.+))?$/);
+  if (!match) {
+    console.error(
+      `  \x1B[31merror:\x1B[0m Invalid package format. Expected: @namespace/slug or @namespace/slug@version`
+    );
+    process.exit(1);
+  }
+  const [, namespace, slug, version] = match;
+  const registryUrl = process.env.AXINT_REGISTRY_URL ?? "https://registry.axint.ai";
+  console.log(
+    `  \x1B[2m\u23FA\x1B[0m Fetching ${namespace}/${slug}${version ? `@${version}` : ""}\u2026`
+  );
+  try {
+    const params = new URLSearchParams({ namespace, slug });
+    if (version) params.set("version", version);
+    const res = await fetch(`${registryUrl}/api/v1/install?${params}`, {
+      headers: { "X-Axint-Version": VERSION }
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ detail: res.statusText }));
+      console.error(
+        `  \x1B[31m\u2717\x1B[0m ${err.detail ?? `Template not found (HTTP ${res.status})`}`
+      );
+      process.exit(1);
+    }
+    const data = await res.json();
+    const targetDir = resolve2(options.to, slug);
+    mkdirSync(targetDir, { recursive: true });
+    const ver = data.version;
+    const filesWritten = [];
+    if (ver.ts_source) {
+      writeFileSync(resolve2(targetDir, "intent.ts"), ver.ts_source, "utf-8");
+      filesWritten.push("intent.ts");
+    }
+    if (ver.py_source) {
+      writeFileSync(resolve2(targetDir, "intent.py"), ver.py_source, "utf-8");
+      filesWritten.push("intent.py");
+    }
+    writeFileSync(resolve2(targetDir, "intent.swift"), ver.swift_output, "utf-8");
+    filesWritten.push("intent.swift");
+    console.log(
+      `  \x1B[32m\u2713\x1B[0m Installed ${data.template.full_name}@${ver.version}`
+    );
+    console.log(`    \u2192 ${targetDir}/`);
+    filesWritten.forEach((f) => console.log(`      ${f}`));
+    console.log();
+    console.log(`  \x1B[1mNext:\x1B[0m`);
+    console.log(`    axint compile ${options.to}/${slug}/intent.ts --out ios/Intents/`);
+    console.log();
+  } catch (err) {
+    console.error(`  \x1B[31merror:\x1B[0m ${err.message ?? err}`);
+    process.exit(1);
+  }
+});
+program.command("search").description("Search the Axint Registry for intent templates").argument("[query]", "Search term (lists popular packages if omitted)").option("--limit <n>", "Max results", "20").option("--json", "Output as JSON").action(
+  async (query, options) => {
+    const registryUrl = process.env.AXINT_REGISTRY_URL ?? "https://registry.axint.ai";
+    const limit = Math.max(1, Math.min(100, parseInt(options.limit, 10) || 20));
+    console.log();
+    if (!options.json) {
+      console.log(
+        `  \x1B[38;5;208m\u25C6\x1B[0m \x1B[1mAxint\x1B[0m \xB7 search ${query ? `"${query}"` : ""}`
+      );
+      console.log();
+    }
+    try {
+      const params = new URLSearchParams({ limit: String(limit) });
+      if (query) params.set("q", query);
+      const res = await fetch(`${registryUrl}/api/v1/search?${params}`, {
+        headers: { "X-Axint-Version": VERSION }
+      });
+      if (!res.ok) {
+        console.error(`\x1B[31merror:\x1B[0m Search failed (HTTP ${res.status})`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+      }
+      if (data.results.length === 0) {
+        console.log(`  No packages found`);
+        console.log();
+        return;
+      }
+      for (const pkg3 of data.results) {
+        const downloads = pkg3.downloads > 0 ? `\u25BC ${pkg3.downloads}` : "";
+        const dl = downloads ? `  \x1B[2m${downloads}\x1B[0m` : "";
+        console.log(
+          `  \x1B[38;5;208m\u25C6\x1B[0m ${pkg3.package_name.padEnd(30)} ${pkg3.description.substring(0, 35).padEnd(35)}${dl}`
+        );
+      }
+      console.log();
+      console.log(
+        `  ${data.results.length} package${data.results.length === 1 ? "" : "s"} found`
+      );
+      console.log();
+      console.log(
+        `  \x1B[2mInstall:\x1B[0m axint add ${data.results[0]?.package_name ?? "@namespace/slug"}`
+      );
+      console.log();
+    } catch (err) {
+      console.error(`\x1B[31merror:\x1B[0m ${err.message ?? err}`);
+      process.exit(1);
+    }
+  }
+);
+async function runSwiftBuild2(projectPath) {
+  return new Promise((resolve3) => {
+    const t0 = performance.now();
+    const proc = spawn4("swift", ["build"], {
+      cwd: projectPath,
+      stdio: ["ignore", "inherit", "inherit"]
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        const dt = (performance.now() - t0).toFixed(0);
+        console.log();
+        console.log(`\x1B[38;5;208m\u2500 swift build\x1B[0m`);
+        console.log(`\x1B[32m\u2713\x1B[0m Build succeeded \x1B[90m(${dt}ms)\x1B[0m`);
+        console.log();
+        resolve3(true);
+      } else {
+        console.log();
+        console.log(`\x1B[38;5;208m\u2500 swift build\x1B[0m`);
+        console.log(`\x1B[31m\u2717\x1B[0m Build failed (exit code: ${code})`);
+        console.log("\x1B[90mContinuing to watch for changes\u2026\x1B[0m");
+        console.log();
+        resolve3(false);
+      }
+    });
+    proc.on("error", (err) => {
+      console.log();
+      console.log(`\x1B[38;5;208m\u2500 swift build\x1B[0m`);
+      console.error(`\x1B[31m\u2717\x1B[0m Error: ${err.message}`);
+      console.log("\x1B[90mContinuing to watch for changes\u2026\x1B[0m");
+      console.log();
+      resolve3(false);
+    });
+  });
+}
+program.command("watch").description("Watch intent files and recompile on change").argument("<file>", "Path to a TypeScript intent file or directory of intents").option("-o, --out <dir>", "Output directory for generated Swift", ".").option("--no-validate", "Skip validation of generated Swift").option("--emit-info-plist", "Emit Info.plist fragments alongside Swift files").option("--emit-entitlements", "Emit entitlements fragments alongside Swift files").option("--format", "Pipe generated Swift through swift-format").option(
+  "--strict-format",
+  "Fail if swift-format is missing or errors (implies --format)"
+).option(
+  "--swift-build",
+  "Run `swift build` in the project after successful compilation"
+).option(
+  "--swift-project <path>",
+  "Path to the Swift project root (defaults to --out parent directory)"
+).action(
+  async (file, options) => {
+    const target = resolve2(file);
+    const isDir = existsSync3(target) && statSync(target).isDirectory();
+    const filesToWatch = [];
+    if (isDir) {
+      const { readdirSync } = await import("fs");
+      for (const entry of readdirSync(target)) {
+        if (entry.endsWith(".ts") && !entry.endsWith(".d.ts")) {
+          filesToWatch.push(resolve2(target, entry));
+        }
+      }
+      if (filesToWatch.length === 0) {
+        console.error(`\x1B[31merror:\x1B[0m No .ts files found in ${target}`);
+        process.exit(1);
+      }
+    } else {
+      if (!existsSync3(target)) {
+        console.error(`\x1B[31merror:\x1B[0m File not found: ${target}`);
+        process.exit(1);
+      }
+      filesToWatch.push(target);
+    }
+    const swiftProjectPath = options.swiftProject ?? dirname2(resolve2(options.out));
+    function compileOne(filePath) {
+      const t0 = performance.now();
+      const result = compileFile(filePath, {
+        outDir: options.out,
+        validate: options.validate,
+        emitInfoPlist: options.emitInfoPlist,
+        emitEntitlements: options.emitEntitlements
+      });
+      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}`);
+      }
+      if (!result.success || !result.output) {
+        const errors = result.diagnostics.filter((d) => d.severity === "error").length;
+        console.error(`\x1B[31m\u2717\x1B[0m ${basename(filePath)} \u2014 ${errors} error(s)`);
+        return false;
+      }
+      const swiftCode = result.output.swiftCode;
+      if (options.format || options.strictFormat) {
+      }
+      const outPath = resolve2(result.output.outputPath);
+      mkdirSync(dirname2(outPath), { recursive: true });
+      writeFileSync(outPath, swiftCode, "utf-8");
+      if (options.emitInfoPlist && result.output.infoPlistFragment) {
+        const plistPath = outPath.replace(/\.swift$/, ".plist.fragment.xml");
+        writeFileSync(plistPath, result.output.infoPlistFragment, "utf-8");
+      }
+      if (options.emitEntitlements && result.output.entitlementsFragment) {
+        const entPath = outPath.replace(/\.swift$/, ".entitlements.fragment.xml");
+        writeFileSync(entPath, result.output.entitlementsFragment, "utf-8");
+      }
+      const dt = (performance.now() - t0).toFixed(1);
+      console.log(
+        `\x1B[32m\u2713\x1B[0m ${result.output.ir.name} \u2192 ${outPath} \x1B[90m(${dt}ms)\x1B[0m`
+      );
+      return true;
+    }
+    async function compileWithFormat(filePath) {
+      if (!options.format && !options.strictFormat) {
+        return compileOne(filePath);
+      }
+      const t0 = performance.now();
+      const result = compileFile(filePath, {
+        outDir: options.out,
+        validate: options.validate,
+        emitInfoPlist: options.emitInfoPlist,
+        emitEntitlements: options.emitEntitlements
+      });
+      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}`);
+      }
+      if (!result.success || !result.output) {
+        const errors = result.diagnostics.filter((d) => d.severity === "error").length;
+        console.error(`\x1B[31m\u2717\x1B[0m ${basename(filePath)} \u2014 ${errors} error(s)`);
+        return false;
+      }
+      let swiftCode = result.output.swiftCode;
+      try {
+        const { formatSwift: formatSwift2 } = await Promise.resolve().then(() => (init_format(), format_exports));
+        const fmt = await formatSwift2(swiftCode, { strict: options.strictFormat });
+        if (fmt.ran) swiftCode = fmt.formatted;
+      } catch (fmtErr) {
+        if (options.strictFormat) {
+          console.error(`\x1B[31merror:\x1B[0m ${fmtErr.message}`);
+          return false;
+        }
+      }
+      const outPath = resolve2(result.output.outputPath);
+      mkdirSync(dirname2(outPath), { recursive: true });
+      writeFileSync(outPath, swiftCode, "utf-8");
+      if (options.emitInfoPlist && result.output.infoPlistFragment) {
+        writeFileSync(
+          outPath.replace(/\.swift$/, ".plist.fragment.xml"),
+          result.output.infoPlistFragment,
+          "utf-8"
+        );
+      }
+      if (options.emitEntitlements && result.output.entitlementsFragment) {
+        writeFileSync(
+          outPath.replace(/\.swift$/, ".entitlements.fragment.xml"),
+          result.output.entitlementsFragment,
+          "utf-8"
+        );
+      }
+      const dt = (performance.now() - t0).toFixed(1);
+      console.log(
+        `\x1B[32m\u2713\x1B[0m ${result.output.ir.name} \u2192 ${outPath} \x1B[90m(${dt}ms)\x1B[0m`
+      );
+      return true;
+    }
+    console.log(`\x1B[1maxint watch\x1B[0m \u2014 ${filesToWatch.length} file(s)
+`);
+    let ok = 0;
+    let fail = 0;
+    for (const f of filesToWatch) {
+      if (await compileWithFormat(f)) {
+        ok++;
+      } else {
+        fail++;
+      }
+    }
+    console.log();
+    if (fail > 0) {
+      console.log(
+        `\x1B[33m\u26A0\x1B[0m ${ok} compiled, ${fail} failed \u2014 watching for changes\u2026
+`
+      );
+    } else {
+      console.log(`\x1B[32m\u2713\x1B[0m ${ok} compiled \u2014 watching for changes\u2026
+`);
+      if (options.swiftBuild) {
+        await runSwiftBuild2(swiftProjectPath);
+      }
+    }
+    const pending = /* @__PURE__ */ new Map();
+    const DEBOUNCE_MS = 150;
+    let batchInProgress = false;
+    function onFileChange(filePath) {
+      const existing = pending.get(filePath);
+      if (existing) clearTimeout(existing);
+      pending.set(
+        filePath,
+        setTimeout(async () => {
+          pending.delete(filePath);
+          if (batchInProgress) return;
+          batchInProgress = true;
+          try {
+            const now = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+            console.log(`\x1B[90m[${now}]\x1B[0m ${basename(filePath)} changed`);
+            const compiled = await compileWithFormat(filePath);
+            console.log();
+            if (compiled && options.swiftBuild) {
+              await runSwiftBuild2(swiftProjectPath);
+            }
+          } finally {
+            batchInProgress = false;
+          }
+        }, DEBOUNCE_MS)
+      );
+    }
+    if (isDir) {
+      const dirWatcher = fsWatch(target, { persistent: true }, (_event, filename) => {
+        if (filename && typeof filename === "string" && filename.endsWith(".ts") && !filename.endsWith(".d.ts")) {
+          onFileChange(resolve2(target, filename));
+        }
+      });
+      dirWatcher.on("error", (err) => {
+        console.error(`\x1B[31m\u2717\x1B[0m watcher error: ${err.message}`);
+      });
+    } else {
+      const parentDir = dirname2(target);
+      const targetBase = basename(target);
+      const fileWatcher = fsWatch(
+        parentDir,
+        { persistent: true },
+        (_event, filename) => {
+          if (filename === targetBase) {
+            onFileChange(target);
+          }
+        }
+      );
+      fileWatcher.on("error", (err) => {
+        console.error(`\x1B[31m\u2717\x1B[0m watcher error: ${err.message}`);
+      });
+    }
+    process.on("SIGINT", () => {
+      console.log("\n\x1B[90mStopped watching.\x1B[0m");
+      process.exit(0);
+    });
+  }
+);
+program.command("mcp").description(
+  "Start the Axint MCP server (stdio) for Claude Code, Cursor, Windsurf, Zed, or any MCP client"
+).action(async () => {
+  const { startMCPServer: startMCPServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  await startMCPServer2();
+});
+function __axintExistsSync(p) {
+  return existsSync3(p);
+}
+program.parse();
+export {
+  __axintExistsSync
+};
 //# sourceMappingURL=index.js.map