@axintai/compiler 0.3.0 → 0.3.1

package/README.md

@@ -63,10 +63,10 @@ Axint is the fastest path from an AI coding tool to a shipped App Intent. **One
 - **Native type fidelity.** `int → Int`, `double → Double`, `float → Float`, `date → Date`, `url → URL`, `duration → Measurement<UnitDuration>`, `optional<T> → T?`. Default values and optionality are preserved end-to-end.
 - **Return-type-aware `perform()` signatures.** Every generated intent is a drop-in tool for Agent Siri and Shortcuts.
 - **Info.plist and .entitlements emit.** Axint writes the `NSAppIntentsDomains` plist fragment and the App Intents entitlement XML alongside your `.swift` file. Drop all three into Xcode and ship.
-- **MCP-native.** A bundled `axint-mcp` server exposes `axint_scaffold`, `axint_compile`, and `axint_validate` to any MCP client. Your AI coding agent can read your project, draft a TypeScript intent, compile it, and open a PR — without a human touching Xcode.
+- **MCP-native.** A bundled `axint-mcp` server exposes five tools — `axint_scaffold`, `axint_compile`, `axint_validate`, `axint_list_templates`, and `axint_template` — to any MCP client. Your AI coding agent can read your project, draft a TypeScript intent, compile it, and open a PR — without a human touching Xcode.
 - **Rust-grade diagnostics.** 16 diagnostic codes (`AX001`–`AX202`) with fix suggestions and color-coded output.
 - **Sub-millisecond compile.** A typical intent compiles in under a millisecond. The [axint.ai playground](https://axint.ai/#playground) runs the full compiler in your browser with zero server round-trip.
-- **152 tests.** Parser, validator, generator, emit paths, and sandbox — all covered.
+- **155 tests.** Parser, validator, generator, emit paths, watch mode, and sandbox — all covered.
 - **Apache 2.0, no CLA.** Fork it, extend it, ship it.
 
 ---
@@ -120,6 +120,31 @@ ios/Intents/
 
 ---
 
+## Watch mode
+
+For iterative development, `axint watch` recompiles on every save with sub-millisecond rebuilds:
+
+```bash
+# Watch a single file
+axint watch my-intent.ts --out ios/Intents/
+
+# Watch a directory of intents
+axint watch ./intents/ --out ios/Intents/ --emit-info-plist --emit-entitlements
+
+# With swift-format
+axint watch my-intent.ts --out ios/Intents/ --format
+
+# Auto-run swift build after each compile
+axint watch ./intents/ --out ios/Intents/ --swift-build
+
+# Specify the Swift project root (defaults to --out parent)
+axint watch ./intents/ --out ios/Sources/Intents/ --swift-build --swift-project ios/
+```
+
+The watcher runs an initial compile pass, then re-triggers on file changes with a 150ms debounce. Errors are reported inline without killing the process — fix the file and it recompiles automatically. With `--swift-build`, each successful compile triggers `swift build` in the project directory so you get immediate feedback on whether the generated Swift compiles cleanly.
+
+---
+
 ## Compiled Swift output
 
 ```swift
@@ -183,13 +208,15 @@ Axint ships with `axint-mcp`, a Model Context Protocol server that exposes the c
 }
 ```
 
-Three tools are exposed:
+Five tools are exposed:
 
-| Tool              | What it does                                                               |
-| ----------------- | -------------------------------------------------------------------------- |
-| `axint_scaffold`  | Generates a TypeScript intent from a natural-language description          |
-| `axint_compile`   | Runs the full pipeline and returns `.swift` + `.plist` + `.entitlements`   |
-| `axint_validate`  | Dry-run validation with line/column diagnostics                            |
+| Tool                  | What it does                                                               |
+| --------------------- | -------------------------------------------------------------------------- |
+| `axint_scaffold`      | Generates a TypeScript intent from a natural-language description          |
+| `axint_compile`       | Runs the full pipeline and returns `.swift` + `.plist` + `.entitlements`   |
+| `axint_validate`      | Dry-run validation with line/column diagnostics                            |
+| `axint_list_templates`| Lists all bundled intent templates                                         |
+| `axint_template`      | Returns the source of a specific bundled template                          |
 
 Once connected, your AI coding agent can read a Swift project, draft an intent, compile it, and open a PR — without a human touching Xcode.
 
@@ -272,7 +299,7 @@ axint/
 │   ├── mcp/         # MCP server (scaffold, compile, validate)
 │   ├── cli/         # axint CLI (Commander.js)
 │   └── templates/   # Intent template registry
-├── tests/           # 117 vitest tests
+├── tests/           # 155 vitest tests
 ├── examples/        # Example intent definitions
 └── docs/            # Error reference, contributing, assets
 ```
@@ -300,10 +327,11 @@ See [`ROADMAP.md`](ROADMAP.md) for the full plan. Highlights:
 - [x] Info.plist and `.entitlements` emit (v0.2.0)
 - [x] Return-type-aware `perform()` (v0.2.0)
 - [x] MCP scaffold tool (v0.2.0)
-- [x] 152-test suite with snapshot coverage (v0.2.0)
-- [ ] Intent template library (v0.3.0)
-- [ ] `--watch` mode for live Swift preview
-- [ ] Xcode build plugin
+- [x] 155-test suite with snapshot coverage (v0.2.0+)
+- [x] Intent template library with 12+ templates (v0.3.0)
+- [x] `--watch` mode with `--swift-build` for live recompilation (v0.3.0)
+- [x] SPM build plugin — auto-compile during `swift build` (v0.3.0)
+- [x] Registry at registry.axint.ai (v0.3.0)
 - [ ] GitHub template repo (`axint-starter`)
 - [ ] Axint Cloud (hosted compilation)
 

package/dist/cli/index.js

@@ -2077,8 +2077,16 @@ var init_server = __esm({
 // src/cli/index.ts
 init_compiler();
 import { Command } from "commander";
-import { readFileSync as readFileSync3, writeFileSync, mkdirSync, existsSync as existsSync3 } from "fs";
+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
@@ -2343,7 +2351,7 @@ Any agent that supports MCP can now call \`axint_compile\`, \`axint_validate\`,
 - 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://axint.ai/docs
+- Read the docs at https://github.com/agenticempire/axint#readme
 
 ---
 
@@ -2406,7 +2414,9 @@ program.command("init").description("Scaffold a new Axint project (zero-config,
         );
       }
       console.log();
-      console.log(`  \x1B[2mDocs:   https://axint.ai/docs\x1B[0m`);
+      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`
       );
@@ -2731,7 +2741,7 @@ program.command("templates").description("List bundled intent templates").argume
 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: spawn4 } = await import("child_process");
+  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";
@@ -2760,7 +2770,7 @@ program.command("login").description("Authenticate with the Axint Registry via G
     console.log(`  \x1B[2mWaiting for authorization\u2026\x1B[0m`);
     try {
       const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-      spawn4(openCmd, [verification_uri], { stdio: "ignore", detached: true }).unref();
+      spawn5(openCmd, [verification_uri], { stdio: "ignore", detached: true }).unref();
     } catch {
     }
     const pollInterval = (interval ?? 5) * 1e3;
@@ -3006,6 +3016,302 @@ program.command("add").description("Install a template from the Axint Registry")
     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 () => {