@apex-stack/core 0.1.10 → 0.1.12

package/dist/dev-V3LVSS5L.js

@@ -0,0 +1,38 @@
+import {
+  banner,
+  ready,
+  spinner
+} from "./chunk-2L2T47AH.js";
+
+// src/commands/dev.ts
+import { resolve } from "path";
+import { defineCommand } from "citty";
+var devCommand = defineCommand({
+  meta: { name: "dev", description: "Start the Apex JS development server" },
+  args: {
+    root: { type: "positional", required: false, description: "Project root", default: "." },
+    port: { type: "string", description: "Port to listen on", default: "3000" },
+    islands: { type: "boolean", description: "Render in islands mode (static-first)", default: false }
+  },
+  async run({ args }) {
+    const root = resolve(process.cwd(), String(args.root));
+    const port = Number(args.port);
+    process.stdout.write(banner());
+    const sp = spinner(`Starting dev server${args.islands ? " (islands mode)" : ""}\u2026`);
+    try {
+      const { startDevServer } = await import("./server-ODH3M2IG.js");
+      const { port: actual } = await startDevServer({ root, port, islands: Boolean(args.islands) });
+      sp.succeed("Dev server ready");
+      ready([
+        ["Local", `http://localhost:${actual}/`],
+        ["MCP", `http://localhost:${actual}/mcp`]
+      ]);
+    } catch (err) {
+      sp.fail("Failed to start the dev server");
+      throw err;
+    }
+  }
+});
+export {
+  devCommand
+};

package/dist/index.js

@@ -1,8 +1,13 @@
 import {
-  isApexResource,
-  renderPage,
   startDevServer
-} from "./chunk-IEXQ7E5C.js";
+} from "./chunk-SH3XEJGV.js";
+import "./chunk-4VG3CZ6H.js";
+import {
+  isApexResource
+} from "./chunk-DSUIB3JH.js";
+import {
+  renderPage
+} from "./chunk-PAMD24NK.js";
 
 // src/api/defineRoute.ts
 function defineApexRoute(config) {

package/dist/make-4LINTKZH.js

@@ -0,0 +1,89 @@
+// src/commands/make.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { defineCommand } from "citty";
+function pageTemplate(name) {
+  return `<script server lang="ts">
+  export function loader() {
+    return { title: '${name}' }
+  }
+</script>
+
+<template x-data>
+  <main>
+    <h1 x-text="title"></h1>
+  </main>
+</template>
+
+<style scoped>
+  main { max-width: 40rem; margin: 3rem auto; font-family: system-ui, sans-serif; }
+</style>
+`;
+}
+function componentTemplate() {
+  return `<template x-data="{ count: 0 }">
+  <button @click="count++" x-text="count"></button>
+</template>
+
+<style scoped>
+  button { cursor: pointer; }
+</style>
+`;
+}
+function apiTemplate(name) {
+  return `import { defineApexRoute } from '@apex-stack/core'
+import { z } from 'zod'
+
+// GET /api/${name}  \xB7  MCP tool "${name}"
+export default defineApexRoute({
+  method: 'GET',
+  description: 'Describe what ${name} does',
+  input: { name: z.string() },
+  mcp: true,
+  handler: ({ input }) => ({ message: \`Hello, \${input.name}!\` }),
+})
+`;
+}
+function plan(kind, name, root) {
+  switch (kind) {
+    case "page":
+      return { path: join(root, "pages", `${name}.alpine`), contents: pageTemplate(name) };
+    case "component":
+      return { path: join(root, "components", `${name}.alpine`), contents: componentTemplate() };
+    case "api":
+      return { path: join(root, "server", "api", `${name}.ts`), contents: apiTemplate(name) };
+  }
+}
+var makeCommand = defineCommand({
+  meta: { name: "make", description: "Generate a page, component, or API route" },
+  args: {
+    kind: { type: "positional", required: true, description: "page | component | api" },
+    name: { type: "positional", required: true, description: "Name (about, Counter, todos, \u2026)" },
+    root: { type: "string", description: "Project root", default: "." }
+  },
+  run({ args }) {
+    const kind = args.kind;
+    if (kind !== "page" && kind !== "component" && kind !== "api") {
+      console.error(`
+  Unknown type "${args.kind}". Use: page | component | api
+`);
+      process.exit(1);
+    }
+    const root = resolve(process.cwd(), args.root);
+    const { path, contents } = plan(kind, args.name, root);
+    if (existsSync(path)) {
+      console.error(`
+  \u2717 Already exists: ${path}
+`);
+      process.exit(1);
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, contents);
+    console.log(`
+  \u2713 Created ${path.replace(`${root}/`, "")}
+`);
+  }
+});
+export {
+  makeCommand
+};

package/dist/mcp-DL4J6JFJ.js

@@ -0,0 +1,56 @@
+// src/commands/mcp.ts
+import { defineCommand } from "citty";
+var mcpCommand = defineCommand({
+  meta: { name: "mcp", description: "Inspect the local MCP server (list or call tools)" },
+  args: {
+    url: { type: "string", description: "MCP endpoint URL", default: "http://localhost:3000/mcp" },
+    call: { type: "string", description: "Name of a tool to call" },
+    args: { type: "string", description: "JSON arguments for --call", default: "{}" }
+  },
+  async run({ args }) {
+    const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+    const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+    const client = new Client({ name: "apex-mcp-cli", version: "0.0.0" });
+    try {
+      await client.connect(new StreamableHTTPClientTransport(new URL(args.url)));
+    } catch (err) {
+      console.error(
+        `
+  Could not reach an MCP server at ${args.url}
+  Is \`apex dev\` running? ${err.message}
+`
+      );
+      process.exit(1);
+    }
+    if (args.call) {
+      const result = await client.callTool({
+        name: args.call,
+        arguments: JSON.parse(args.args)
+      });
+      console.log(`
+  \x1B[36m${args.call}\x1B[0m(${args.args}) \u2192`);
+      for (const part of result.content) {
+        console.log("  " + (part.text ?? JSON.stringify(part)));
+      }
+      console.log();
+    } else {
+      const { tools } = await client.listTools();
+      console.log(`
+  \x1B[36mMCP tools\x1B[0m at ${args.url} (${tools.length})
+`);
+      for (const t of tools) {
+        const props = t.inputSchema?.properties;
+        const sig = props ? Object.entries(props).map(([k, v]) => `${k}: ${v.type ?? "any"}`).join(", ") : "";
+        console.log(`  \u2022 \x1B[1m${t.name}\x1B[0m(${sig})`);
+        if (t.description) console.log(`    ${t.description}`);
+      }
+      console.log(`
+  Call one:  apex mcp --call <name> --args '{...}'
+`);
+    }
+    await client.close();
+  }
+});
+export {
+  mcpCommand
+};

package/dist/migrate-NOGFOFV2.js

@@ -0,0 +1,38 @@
+// src/commands/migrate.ts
+import { createRequire } from "module";
+import { join, resolve } from "path";
+import { pathToFileURL } from "url";
+import { defineCommand } from "citty";
+var migrateCommand = defineCommand({
+  meta: { name: "migrate", description: "Apply pending SQL migrations (db/migrations/*.sql)" },
+  args: {
+    db: { type: "string", description: "SQLite file path (libSQL)", default: "data.db" },
+    driver: { type: "string", description: "sqlite | postgres | pglite", default: "sqlite" },
+    url: { type: "string", description: "Connection URL (postgres) \u2014 overrides --db" },
+    dir: { type: "string", description: "Migrations directory", default: "db/migrations" },
+    root: { type: "string", description: "Project root", default: "." }
+  },
+  async run({ args }) {
+    const root = resolve(process.cwd(), args.root);
+    let data;
+    try {
+      const require2 = createRequire(join(root, "package.json"));
+      data = await import(pathToFileURL(require2.resolve("@apex-stack/data")).href);
+    } catch {
+      console.error("\n  @apex-stack/data is not installed in this project. Run: npm i @apex-stack/data\n");
+      process.exit(1);
+    }
+    const config = args.driver === "postgres" ? { driver: "postgres", url: args.url } : args.driver === "pglite" ? { driver: "pglite", dir: args.url } : resolve(root, args.db);
+    const handle = await data.createDb(config);
+    const applied = await data.applyMigrations(handle, resolve(root, args.dir));
+    await handle.close();
+    console.log(
+      applied.length ? `
+  \u2713 Applied ${applied.length} migration(s): ${applied.join(", ")}
+` : "\n  \u2713 Up to date \u2014 no pending migrations.\n"
+    );
+  }
+});
+export {
+  migrateCommand
+};

package/dist/server-ODH3M2IG.js

@@ -0,0 +1,9 @@
+import {
+  startDevServer
+} from "./chunk-SH3XEJGV.js";
+import "./chunk-4VG3CZ6H.js";
+import "./chunk-DSUIB3JH.js";
+import "./chunk-PAMD24NK.js";
+export {
+  startDevServer
+};

package/dist/start-VJJXI4W3.js

@@ -0,0 +1,132 @@
+import {
+  createApiHandler,
+  createMcpHandler,
+  expandApiModule,
+  hasMcpRoutes
+} from "./chunk-DSUIB3JH.js";
+import {
+  matchRoute,
+  renderIslandsPage,
+  renderPage
+} from "./chunk-PAMD24NK.js";
+
+// src/commands/start.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, resolve } from "path";
+import { defineCommand } from "citty";
+
+// src/prod/server.ts
+import { createServer as createHttpServer } from "http";
+import { existsSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+import { pathToFileURL } from "url";
+import {
+  createApp,
+  defineEventHandler,
+  getRequestURL,
+  setResponseHeader,
+  setResponseStatus,
+  toNodeListener
+} from "h3";
+var MIME = {
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".css": "text/css",
+  ".html": "text/html",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2"
+};
+async function startProdServer(options) {
+  const dir = options.dir;
+  const port = options.port ?? 3e3;
+  const manifest = JSON.parse(readFileSync(join(dir, "apex-manifest.json"), "utf8"));
+  const importServer = (relFile) => import(pathToFileURL(join(dir, "server", relFile)).href);
+  const registry = {};
+  let componentCss = "";
+  for (const [name, file] of Object.entries(manifest.components)) {
+    const mod = await importServer(file);
+    registry[name] = { template: mod.template, rootXData: mod.rootXData, scopeId: mod.scopeId };
+    if (mod.css) componentCss += `${mod.css}
+`;
+  }
+  const apiEntries = [];
+  for (const { name, serverFile } of manifest.api) {
+    const mod = await importServer(serverFile);
+    apiEntries.push(...expandApiModule(name, mod.default));
+  }
+  const serverFileFor = new Map(manifest.routes.map((r) => [r.pageId, r.serverFile]));
+  const loadModule = (id) => importServer(serverFileFor.get(id));
+  const app = createApp();
+  app.use(
+    defineEventHandler((event) => {
+      if (event.method !== "GET") return;
+      const path = decodeURIComponent(getRequestURL(event).pathname);
+      if (path === "/" || path.startsWith("/api") || path === "/mcp") return;
+      const file = join(dir, path);
+      if (!file.startsWith(dir) || !existsSync(file) || !statSync(file).isFile()) return;
+      const ext = path.slice(path.lastIndexOf("."));
+      setResponseHeader(event, "Content-Type", MIME[ext] ?? "application/octet-stream");
+      if (path.startsWith("/assets/")) setResponseHeader(event, "Cache-Control", "public, max-age=31536000, immutable");
+      return readFileSync(file);
+    })
+  );
+  if (apiEntries.length) app.use("/api", createApiHandler(apiEntries));
+  if (hasMcpRoutes(apiEntries)) app.use("/mcp", createMcpHandler(apiEntries));
+  app.use(
+    defineEventHandler(async (event) => {
+      const url = getRequestURL(event).pathname;
+      const matched = matchRoute(manifest.routes, url);
+      if (!matched) {
+        setResponseStatus(event, 404);
+        setResponseHeader(event, "Content-Type", "text/html");
+        return `<!DOCTYPE html><h1>404 \u2014 ${url}</h1>`;
+      }
+      const route = manifest.routes.find((r) => r.pageId === matched.pageId);
+      const render = manifest.islands ? renderIslandsPage : renderPage;
+      const html = await render({
+        loadModule,
+        pageId: matched.pageId,
+        params: matched.params,
+        url,
+        registry,
+        componentCss,
+        clientHref: route?.clientHref
+      });
+      setResponseHeader(event, "Content-Type", "text/html");
+      return html;
+    })
+  );
+  const server = createHttpServer(toNodeListener(app));
+  await new Promise((resolve2) => server.listen(port, resolve2));
+  return { server, port };
+}
+
+// src/commands/start.ts
+var startCommand = defineCommand({
+  meta: { name: "start", description: "Run a production build (from `apex build --server`)" },
+  args: {
+    dir: { type: "positional", required: false, description: "Build directory", default: "dist" },
+    port: { type: "string", description: "Port to listen on", default: "3000" }
+  },
+  async run({ args }) {
+    const dir = resolve(process.cwd(), args.dir);
+    if (!existsSync2(join2(dir, "apex-manifest.json"))) {
+      console.error(`
+  No build found in ${args.dir}/. Run \`apex build --server\` first.
+`);
+      process.exit(1);
+    }
+    const { port } = await startProdServer({ dir, port: Number(args.port) });
+    console.log(`
+  \x1B[36mApex JS\x1B[0m production server
+  \u2192 http://localhost:${port}
+`);
+  }
+});
+export {
+  startCommand
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apex-stack/core",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "The full-stack meta-framework for Alpine.js — CLI and runtime",
   "type": "module",
   "license": "MIT",