mojulo 0.1.0 → 0.1.1

package/README.md

@@ -9,13 +9,14 @@
 claude mcp add mojulo --command "npx -y mojulo"
 
 # 2. Configure at least one LLM provider key
-npx -y mojulo-config set anthropic sk-ant-...
+#    (mojulo-config ships inside the mojulo package, so -p mojulo is required)
+npx -y -p mojulo mojulo-config set anthropic sk-ant-...
 
 # 3. In a Claude session, ask:
 #    "build me a triage bot for my dental practice"
 ```
 
-Compiled bots land in `~/.mojulo/data/artifacts/`. Run them with `docker compose up`, or set a Fly token (`mojulo-config set fly fo1_...`) and ask Claude to deploy to the cloud.
+Compiled bots land in `~/.mojulo/data/artifacts/`. Run them with `docker compose up`, or set a Fly token (`npx -y -p mojulo mojulo-config set fly fo1_...`) and ask Claude to deploy to the cloud.
 
 On first connect, Claude calls `forward_context` to read mojulo's glossary, lifecycle, and tool index — so the session orients itself before doing anything.
 

package/lib/builder/tool-executors.js

@@ -217,6 +217,105 @@ Example:
   }
 }
 
+/**
+ * Extract user-stated bot settings from the prompt via LLM.
+ *
+ * Replaces the English-locked regex in extractPrepopulatedSettings — the LLM
+ * handles "llámalo Maverick" / "把它叫做小助手" / possessives / multi-turn
+ * mentions that the regex misses. Returns the same shape so compose_identity
+ * consumes it unchanged. The botName is slug-normalized here (same rules as
+ * the regex path) so downstream code doesn't have to know which extractor ran.
+ *
+ * Returns null when no API key is available (signal to caller to fall back to
+ * regex). Returns {} on parse/validation failure.
+ */
+async function extractPrepopulatedSettingsLLM(userMessage, session, userId) {
+  let llmConfig;
+  try {
+    llmConfig = await getLLMConfigFromSession(session, userId, 'summary');
+  } catch (err) {
+    console.log('[Builder] No API key for prepopulated extraction:', err.message);
+    return null;
+  }
+
+  const { provider, apiKey, model } = llmConfig;
+  const { generateSummary } = await import('@/lib/llm-providers.js');
+
+  const prompt = `Extract user-specified settings from this bot-building request. The user may write in any language (English, Spanish, Chinese, Polish, Arabic, etc.).
+
+USER REQUEST:
+${userMessage.substring(0, 1000)}
+
+Extract these fields IF — and only if — the user explicitly states them. Do not invent or infer.
+
+- displayName: The proper-noun name the user gave the bot (e.g. "Maverick", "小助手", "Pelusa"). Preserve original script and capitalization. Omit if not stated.
+- resourceName: The organization/company/brand the bot is for (e.g. "Acme Dental", "Valley Coffee"). Omit if not stated.
+- firstMessage: An exact greeting/welcome message the user dictated in quotes. Omit if not stated.
+- objective: An exact purpose/goal the user dictated in quotes. Omit if not stated.
+
+Return ONLY a JSON object with whichever fields are present, no other text. Empty object {} if nothing was stated.
+
+Examples:
+- "build me a bot called Maverick for Acme Dental" → {"displayName": "Maverick", "resourceName": "Acme Dental"}
+- "llámalo Sparky" → {"displayName": "Sparky"}
+- "把这个机器人叫做小助手,给阳光咖啡馆用的" → {"displayName": "小助手", "resourceName": "阳光咖啡馆"}
+- "I need a support bot" → {}`;
+
+  try {
+    const response = await generateSummary(
+      provider,
+      prompt,
+      apiKey,
+      'Extract bot settings from user request',
+      model
+    );
+
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) return {};
+
+    const extracted = JSON.parse(jsonMatch[0]);
+    const settings = {};
+
+    if (typeof extracted.displayName === 'string' && extracted.displayName.trim()) {
+      const displayName = extracted.displayName.trim().substring(0, 40);
+      settings.displayName = displayName;
+      // Slug for botName: collapse to a-z0-9-, max 30. For non-ASCII names
+      // the slug ends up empty — fall back to a transliteration-free hash so
+      // the bot still has a stable id while displayName carries the original.
+      const slug = displayName
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .substring(0, 30);
+      if (slug) {
+        settings.botName = slug;
+      }
+      // No slug fallback: leaving botName unset lets compose_identity generate
+      // an org-derived slug, which is more useful than a hash to the operator.
+    }
+
+    if (typeof extracted.resourceName === 'string' && extracted.resourceName.trim()) {
+      settings.resourceName = extracted.resourceName.trim().substring(0, 60);
+    }
+
+    if (typeof extracted.firstMessage === 'string' && extracted.firstMessage.trim()) {
+      settings.firstMessage = extracted.firstMessage.trim().substring(0, 200);
+    }
+
+    if (typeof extracted.objective === 'string' && extracted.objective.trim()) {
+      settings.objective = extracted.objective.trim().substring(0, 250);
+    }
+
+    console.log('[Builder] LLM-extracted prepopulated settings:', settings);
+    return settings;
+  } catch (err) {
+    console.warn('[Builder] Failed to LLM-extract prepopulated settings:', err.message);
+    return {};
+  }
+}
+
 /**
  * Execute a modular tool call
  * @param {string} toolName - Name of the tool
@@ -614,8 +713,13 @@ const builderToolHandlers = {
       }
     }
 
-    // Extract prepopulated settings from user message
-    const prepopulatedSettings = extractPrepopulatedSettings(userMessage);
+    // Extract prepopulated settings from user message.
+    // LLM extractor handles any language; regex is the fallback when no API
+    // key is configured (returns null) or when the LLM yields nothing useful.
+    const llmSettings = await extractPrepopulatedSettingsLLM(userMessage, session, userId);
+    const prepopulatedSettings = (llmSettings && Object.keys(llmSettings).length > 0)
+      ? llmSettings
+      : extractPrepopulatedSettings(userMessage);
 
     // Update session with inference and prepopulated settings
     await BuilderSessionRepository.updateInference(session.id, userId, {
@@ -1395,15 +1499,20 @@ Return ONLY the summary text, nothing else.`;
 
       let buildStatus = result.status;
       let buildError = null;
+      // artifactPath is the absolute on-disk zip — surfaced so MCP/stdio
+      // callers (which have no HTTP server to hit downloadUrl against) can
+      // hand the user a real path. Web flow keeps using downloadUrl.
+      let artifactPath = null;
       try {
-        const { deployment } = await buildArtifact(result.deploymentId);
-        buildStatus = deployment.status;
+        const built = await buildArtifact(result.deploymentId);
+        buildStatus = built.deployment.status;
+        artifactPath = built.artifactPath;
       } catch (err) {
         console.error('[save_modular_bot] build after save failed:', err);
         buildError = err.message || 'Build failed';
       }
 
-      return { ...result, isUpdate, status: buildStatus, buildError };
+      return { ...result, isUpdate, status: buildStatus, buildError, artifactPath };
     }
 
     await BuilderSessionRepository.updateStatus(sessionId, userId, SESSION_STATUS.AWAITING_CONFIRM);

package/lib/mcp/tools/context.js

@@ -75,7 +75,7 @@ That density runs through the whole body — numbered synthesis steps, mapping r
 1. **Build.** Pick which protocols (capabilities) the bot needs, generate their configs, upload any documents the bot should know, compose the bot's identity. Either drive this step-by-step through the build tools, or just describe the user's goal and let the build tools sequence themselves starting from \`infer_intent\`.
 
    *Builder-session scope.* Build tools share state via a **builder session** keyed on the \`mcp-session-id\` header your client sends. The session row persists in the control plane's SQLite, but the header→session binding is held in process memory. So: the same client reconnecting during a single control-plane process lifetime resumes its in-progress config, while a **control-plane restart drops the binding** and the user's next build tool call starts a fresh bot (the orphaned row stays in SQLite). Inside the same connection, \`start_new_bot\` deliberately discards in-progress config and starts over.
-2. **Deploy.** \`save_modular_bot\` compiles the configured bot into a downloadable zip artifact. The user runs it locally (Docker) or in the cloud (Fly.io). The container image is bot-agnostic — per-bot config is injected at start time, so the same image runs every bot the user has.
+2. **Deploy.** \`save_modular_bot\` compiles the configured bot into a zip artifact on disk and returns its absolute path in \`artifactPath\`. The user runs it locally (\`unzip\` + \`docker compose up\`) or in the cloud (Fly.io). Over stdio MCP the zip lives under \`$MOJULO_HOME/data/artifacts/\` (default \`~/.mojulo/data/artifacts/\`) — hand the user the \`artifactPath\` value verbatim. The legacy \`downloadUrl\` field in the response is a Next.js-route path; ignore it over stdio. The container image is bot-agnostic — per-bot config is injected at start time, so the same image runs every bot the user has.
 3. **Connect.** Once the bot starts, it phones home to the control plane with its URL. From then on the control plane can reach it through a bearer-authenticated proxy. **Conversation data stays in the bot's SQLite forever** — the control plane only stores \`url\` and \`last_seen_at\`. Any tool that needs transcript data proxies through to the bot in real time.
 4. **Operate.** Use the operate tools to read what bots have captured. Use the catalyst tools to turn that captured signal into action via the user's other installed MCPs.
 5. **Operate the fleet.** Once multiple bots are connected, fleet-level questions ("how is the whole fleet doing?", "which bots saw the most activity?", "find any conversation across every bot that mentioned X") have their own surface — the \`fleet_*\` tools. They fan out across every connected bot and aggregate in process memory; conversation content still stays on each bot. The natural two-step pattern is **fleet-locate** with \`fleet_query_conversations\` → **per-bot-read** with \`get_conversation\`. Same posture as single-bot operate, just batched. Cross-bot catalysts (the new category fleet aggregation enables) come from \`recommend_catalysts\` with \`scope: 'fleet'\`.
@@ -103,7 +103,7 @@ That density runs through the whole body — numbered synthesis steps, mapping r
 ### Build, documents and artifact compilation
 - \`upload_document_from_url\` — **sync**, ~1–5s. Upload a PDF / DOCX / TXT / MD / HTML the bot should learn from. Accepts a URL, base64, or pre-extracted text. → returns \`{ documentId, originalName, mimeType, sizeBytes, message }\`. Pass \`documentId\` into \`process_documents\`.
 - \`process_documents\` — **async**, returns \`{ jobId }\`. ~10–30s **per document** (parse + chunk + embed + per-doc LLM summary). Many or large docs can run minutes. Makes documents available to the \`knowledge\` protocol.
-- \`save_modular_bot\` — **async**, returns \`{ jobId }\`. ~10–60s in prebuilt-image mode (compose cartridges + write config + zip); longer when the control plane is in offline-build mode (\`MOJULO_OFFLINE_BUILD=1\` bundles full bot source). Compiles the configured bot into the downloadable artifact.
+- \`save_modular_bot\` — **async**, returns \`{ jobId }\`. ~10–60s in prebuilt-image mode (compose cartridges + write config + zip); longer when the control plane is in offline-build mode (\`MOJULO_OFFLINE_BUILD=1\` bundles full bot source). Compiles the configured bot into a zip on disk. Polled result: \`{ deploymentId, status, botName, artifactPath, buildError, ... }\`. \`artifactPath\` is the absolute path to the zip — that's the value to surface to the user.
 - \`poll_job\` — **sync**. Check the status of any async job. → returns \`{ jobId, tool, status: "pending" | "running" | "done" | "error", progress, result, error }\`. Reasonable polling cadence is every 2–5s.
 
 ### Operate (fleet)

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "mojulo",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "license": "Apache-2.0",
   "description": "Mojulo — MCP server for building self-hosted chatbots from inside Claude.",
   "author": "Franz Ombico",
   "homepage": "https://github.com/zombico/mojulo",
-  "repository": { "type": "git", "url": "git+https://github.com/zombico/mojulo.git" },
-  "bugs": { "url": "https://github.com/zombico/mojulo/issues" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zombico/mojulo.git"
+  },
+  "bugs": {
+    "url": "https://github.com/zombico/mojulo/issues"
+  },
   "keywords": [
     "mcp",
     "claude",
@@ -18,7 +23,9 @@
     "self-hosted",
     "mojulo"
   ],
-  "engines": { "node": ">=20" },
+  "engines": {
+    "node": ">=20"
+  },
   "bin": {
     "mojulo": "./scripts/mcp-stdio.mjs",
     "mojulo-config": "./scripts/mcp-config.mjs"