@leanmcp/cli 0.2.13 → 0.3.0

package/bin/leanmcp.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 // Always prefer ESM build
 import('../dist/index.js');

package/dist/index.js

@@ -17,6 +17,7 @@ import chalk from "chalk";
 import ora from "ora";
 import path3 from "path";
 import fs3 from "fs-extra";
+import crypto from "crypto";
 import chokidar from "chokidar";
 
 // src/vite/scanUIApp.ts
@@ -131,6 +132,29 @@ import react from "@vitejs/plugin-react";
 import { viteSingleFile } from "vite-plugin-singlefile";
 import fs2 from "fs-extra";
 import path2 from "path";
+function resolveReactDependency(startDir, packageName) {
+  const localPath = path2.join(startDir, "node_modules", packageName);
+  if (fs2.existsSync(localPath)) {
+    return localPath;
+  }
+  let currentDir = path2.dirname(startDir);
+  const maxDepth = 10;
+  let depth = 0;
+  while (depth < maxDepth) {
+    const nodeModulesPath = path2.join(currentDir, "node_modules", packageName);
+    if (fs2.existsSync(nodeModulesPath)) {
+      return nodeModulesPath;
+    }
+    const parentDir = path2.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+    depth++;
+  }
+  return localPath;
+}
+__name(resolveReactDependency, "resolveReactDependency");
 async function buildUIComponent(uiApp, projectDir, isDev = false) {
   const { componentPath, componentName, resourceUri } = uiApp;
   const safeFileName = resourceUri.replace("ui://", "").replace(/\//g, "-") + ".html";
@@ -218,6 +242,17 @@ module.exports = {
     plugins: [],
 }
 `);
+  const tsconfigPath = path2.join(tempDir, "tsconfig.json");
+  await fs2.writeFile(tsconfigPath, JSON.stringify({
+    compilerOptions: {
+      target: "ES2020",
+      jsx: "react-jsx",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      skipLibCheck: true,
+      esModuleInterop: true
+    }
+  }, null, 2));
   const stylesCss = path2.join(tempDir, "styles.css");
   await fs2.writeFile(stylesCss, `
 @tailwind base;
@@ -307,12 +342,23 @@ createRoot(document.getElementById('root')!).render(
 );
 `);
   try {
+    const reactPath = resolveReactDependency(projectDir, "react");
+    const reactDomPath = resolveReactDependency(projectDir, "react-dom");
     await vite.build({
       root: tempDir,
       plugins: [
         react(),
         viteSingleFile()
       ],
+      resolve: {
+        alias: {
+          // Resolve React from project or workspace root node_modules
+          "react": reactPath,
+          "react-dom": reactDomPath,
+          "react/jsx-runtime": path2.join(reactPath, "jsx-runtime"),
+          "react/jsx-dev-runtime": path2.join(reactPath, "jsx-dev-runtime")
+        }
+      },
       css: {
         postcss: {
           plugins: [
@@ -366,8 +412,49 @@ async function writeUIManifest(manifest, projectDir) {
   });
 }
 __name(writeUIManifest, "writeUIManifest");
+async function deleteUIComponent(uri, projectDir) {
+  const safeFileName = uri.replace("ui://", "").replace(/\//g, "-") + ".html";
+  const htmlPath = path2.join(projectDir, "dist", "ui", safeFileName);
+  if (await fs2.pathExists(htmlPath)) {
+    await fs2.remove(htmlPath);
+  }
+}
+__name(deleteUIComponent, "deleteUIComponent");
 
 // src/commands/dev.ts
+function computeHash(filePath) {
+  const content = fs3.readFileSync(filePath, "utf-8");
+  return crypto.createHash("md5").update(content).digest("hex");
+}
+__name(computeHash, "computeHash");
+function computeDiff(previousUIApps, currentUIApps, hashCache) {
+  const previousURIs = new Set(previousUIApps.map((app) => app.resourceUri));
+  const currentURIs = new Set(currentUIApps.map((app) => app.resourceUri));
+  const removed = Array.from(previousURIs).filter((uri) => !currentURIs.has(uri));
+  const added = new Set(Array.from(currentURIs).filter((uri) => !previousURIs.has(uri)));
+  const addedOrChanged = [];
+  for (const app of currentUIApps) {
+    const isNew = added.has(app.resourceUri);
+    if (isNew) {
+      addedOrChanged.push(app);
+    } else {
+      const oldHash = hashCache.get(app.resourceUri);
+      let newHash;
+      if (fs3.existsSync(app.componentPath)) {
+        newHash = computeHash(app.componentPath);
+      }
+      if (oldHash !== newHash) {
+        addedOrChanged.push(app);
+      }
+    }
+  }
+  return {
+    removed,
+    added,
+    addedOrChanged
+  };
+}
+__name(computeDiff, "computeDiff");
 async function devCommand() {
   const cwd = process.cwd();
   if (!await fs3.pathExists(path3.join(cwd, "main.ts"))) {
@@ -375,16 +462,13 @@ async function devCommand() {
     console.error(chalk.gray("Run this command from your project root."));
     process.exit(1);
   }
-  console.log(chalk.cyan("\n\u{1F680} LeanMCP Development Server\n"));
+  console.log(chalk.cyan("\nLeanMCP Development Server\n"));
   const scanSpinner = ora("Scanning for @UIApp components...").start();
   const uiApps = await scanUIApp(cwd);
   if (uiApps.length === 0) {
-    scanSpinner.succeed("No @UIApp components found");
+    scanSpinner.info("No @UIApp components found");
   } else {
-    scanSpinner.succeed(`Found ${uiApps.length} @UIApp component(s)`);
-    for (const app of uiApps) {
-      console.log(chalk.gray(`   \u2022 ${app.componentName} \u2192 ${app.resourceUri}`));
-    }
+    scanSpinner.info(`Found ${uiApps.length} @UIApp component(s)`);
   }
   const manifest = {};
   if (uiApps.length > 0) {
@@ -402,10 +486,10 @@ async function devCommand() {
     if (errors.length > 0) {
       buildSpinner.warn("Built with warnings");
       for (const error of errors) {
-        console.error(chalk.yellow(`   \u26A0 ${error}`));
+        console.error(chalk.yellow(`   ${error}`));
       }
     } else {
-      buildSpinner.succeed("UI components built");
+      buildSpinner.info("UI components built");
     }
   }
   console.log(chalk.cyan("\nStarting development server...\n"));
@@ -419,31 +503,66 @@ async function devCommand() {
     shell: true
   });
   let watcher = null;
-  if (uiApps.length > 0) {
-    const componentPaths = uiApps.map((app) => app.componentPath);
-    watcher = chokidar.watch(componentPaths, {
-      ignoreInitial: true
-    });
-    watcher.on("change", async (changedPath) => {
-      const app = uiApps.find((a) => a.componentPath === changedPath);
-      if (!app) return;
-      console.log(chalk.cyan(`
-[UI] Rebuilding ${app.componentName}...`));
-      const result = await buildUIComponent(app, cwd, true);
-      if (result.success) {
-        manifest[app.resourceUri] = result.htmlPath;
-        await writeUIManifest(manifest, cwd);
-        console.log(chalk.green(`[UI] ${app.componentName} rebuilt successfully`));
-      } else {
-        console.log(chalk.yellow(`[UI] ${app.componentName} build failed: ${result.error}`));
-      }
-    });
+  const componentHashCache = /* @__PURE__ */ new Map();
+  for (const app of uiApps) {
+    if (await fs3.pathExists(app.componentPath)) {
+      componentHashCache.set(app.resourceUri, computeHash(app.componentPath));
+    }
   }
+  let previousUIApps = uiApps;
+  const mcpPath = path3.join(cwd, "mcp");
+  watcher = chokidar.watch(mcpPath, {
+    ignoreInitial: true,
+    ignored: [
+      "**/node_modules/**",
+      "**/*.d.ts"
+    ],
+    persistent: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 100,
+      pollInterval: 50
+    }
+  });
+  let debounceTimer = null;
+  watcher.on("all", async (event, changedPath) => {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+      const currentUIApps = await scanUIApp(cwd);
+      const diff = computeDiff(previousUIApps, currentUIApps, componentHashCache);
+      if (diff.removed.length === 0 && diff.addedOrChanged.length === 0) {
+        return;
+      }
+      for (const uri of diff.removed) {
+        console.log(chalk.yellow(`Removing ${uri}...`));
+        await deleteUIComponent(uri, cwd);
+        delete manifest[uri];
+        componentHashCache.delete(uri);
+      }
+      for (const app of diff.addedOrChanged) {
+        const action = diff.added.has(app.resourceUri) ? "Building" : "Rebuilding";
+        console.log(chalk.cyan(`${action} ${app.componentName}...`));
+        const result = await buildUIComponent(app, cwd, true);
+        if (result.success) {
+          manifest[app.resourceUri] = result.htmlPath;
+          if (await fs3.pathExists(app.componentPath)) {
+            componentHashCache.set(app.resourceUri, computeHash(app.componentPath));
+          }
+          console.log(chalk.green(`${app.componentName} ${action.toLowerCase()} complete`));
+        } else {
+          console.log(chalk.yellow(`Build failed: ${result.error}`));
+        }
+      }
+      await writeUIManifest(manifest, cwd);
+      previousUIApps = currentUIApps;
+    }, 150);
+  });
+  let isCleaningUp = false;
   const cleanup = /* @__PURE__ */ __name(() => {
+    if (isCleaningUp) return;
+    isCleaningUp = true;
     console.log(chalk.gray("\nShutting down..."));
     if (watcher) watcher.close();
-    devServer.kill();
-    process.exit(0);
+    devServer.kill("SIGTERM");
   }, "cleanup");
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
@@ -531,10 +650,12 @@ async function startCommand() {
     stdio: "inherit",
     shell: true
   });
+  let isCleaningUp = false;
   const cleanup = /* @__PURE__ */ __name(() => {
+    if (isCleaningUp) return;
+    isCleaningUp = true;
     console.log(chalk2.gray("\nShutting down..."));
-    server.kill();
-    process.exit(0);
+    server.kill("SIGTERM");
   }, "cleanup");
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leanmcp/cli",
-  "version": "0.2.13",
+  "version": "0.3.0",
   "description": "Command-line interface for scaffolding LeanMCP projects",
   "bin": {
     "leanmcp": "bin/leanmcp.js"