@axintai/compiler 0.2.1

package/dist/mcp/index.js

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