daemora 1.0.5 → 1.0.7

package/src/setup/wizard.js

@@ -730,90 +730,69 @@ export async function runSetupWizard() {
     mcpConfig = { mcpServers: {} };
   }
 
-  // ── Preset servers ────────────────────────────────────────────────────────
+  // ── Preset servers (dynamically built from config/mcp.json) ──────────────
   p.log.info(`Press ${t.bold("space")} to select, ${t.bold("enter")} to confirm`);
 
+  const isPlaceholder = (v) => !v || v.startsWith("YOUR_") || v === "" || v.startsWith("${");
+  const allServers = Object.entries(mcpConfig.mcpServers || {})
+    .filter(([k]) => !k.startsWith("_comment"))
+    .map(([name, cfg]) => {
+      const envKeys = cfg.env ? Object.keys(cfg.env) : [];
+      const headerKeys = cfg.headers ? Object.keys(cfg.headers) : [];
+      const needsCreds = envKeys.some(k => isPlaceholder(cfg.env[k]))
+        || headerKeys.some(k => isPlaceholder(cfg.headers[k]));
+      const comment = mcpConfig.mcpServers[`_comment_${name}`] || "";
+      const desc = comment.replace(/^[^-]*-\s*/, "").trim();
+      const hint = desc
+        ? `${desc}${needsCreds ? " \u2014 needs credentials" : " \u2014 no key needed"}`
+        : needsCreds ? "needs credentials" : "no key needed";
+      return { value: name, label: name.charAt(0).toUpperCase() + name.slice(1).replace(/-/g, " "), hint, needsCreds, envKeys, headerKeys, cfg };
+    });
+
   const mcpChoices = guard(await p.multiselect({
     message: "Enable built-in MCP servers",
-    options: [
-      { value: "github",       label: "GitHub",         hint: "Repos, PRs, issues \u2014 needs token" },
-      { value: "brave-search", label: "Brave Search",   hint: "Web search \u2014 needs API key" },
-      { value: "memory",       label: "Memory",         hint: "Knowledge graph \u2014 no key needed" },
-      { value: "filesystem",   label: "Filesystem",     hint: "File access \u2014 no key needed" },
-      { value: "fetch",        label: "Web Fetch",      hint: "Page to text \u2014 no key needed" },
-      { value: "git",          label: "Git",            hint: "Repo operations \u2014 no key needed" },
-      { value: "slack",        label: "Slack",          hint: "Workspace \u2014 needs bot token" },
-      { value: "sentry",       label: "Sentry",         hint: "Error tracking \u2014 needs auth token" },
-    ],
+    options: allServers.map(({ value, label, hint }) => ({ value, label, hint })),
     required: false,
   }));
 
-  for (const server of mcpChoices) {
-    if (!mcpConfig.mcpServers[server]) continue;
+  for (const serverName of mcpChoices) {
+    const serverInfo = allServers.find(s => s.value === serverName);
+    if (!serverInfo || !mcpConfig.mcpServers[serverName]) continue;
 
-    if (server === "github") {
-      p.note(
-        [
-          "1. Go to https://github.com/settings/tokens",
-          "2. Click \"Generate new token (classic)\"",
-          "3. Select scopes: repo, read:org, read:user",
-          "4. Copy the token (starts with ghp_)",
-        ].join("\n"),
-        "Get GitHub Token"
-      );
-      const ghToken = guard(await p.password({ message: "GitHub Personal Access Token" }));
-      if (ghToken) {
-        mcpConfig.mcpServers.github.enabled = true;
-        mcpConfig.mcpServers.github.env.GITHUB_PERSONAL_ACCESS_TOKEN = ghToken;
+    if (serverInfo.needsCreds) {
+      // Dynamically prompt for each env/header credential
+      const credKeys = serverInfo.envKeys.filter(k => isPlaceholder(serverInfo.cfg.env?.[k]));
+      const headerCredKeys = serverInfo.headerKeys.filter(k => isPlaceholder(serverInfo.cfg.headers?.[k]));
+
+      if (credKeys.length > 0 || headerCredKeys.length > 0) {
+        p.log.info(`${t.bold(serverInfo.label)} requires ${credKeys.length + headerCredKeys.length} credential(s)`);
       }
-    } else if (server === "brave-search") {
-      p.note(
-        [
-          "1. Go to https://api.search.brave.com/register",
-          "2. Sign up and get your API key",
-          "3. Free tier: 2,000 queries/month",
-        ].join("\n"),
-        "Get Brave Search Key"
-      );
-      const braveKey = guard(await p.password({ message: "Brave Search API key" }));
-      if (braveKey) {
-        mcpConfig.mcpServers["brave-search"].enabled = true;
-        mcpConfig.mcpServers["brave-search"].env.BRAVE_API_KEY = braveKey;
+
+      let allFilled = true;
+      for (const key of credKeys) {
+        const val = guard(await p.password({ message: `${key} for ${serverInfo.label}` }));
+        if (val) {
+          mcpConfig.mcpServers[serverName].env[key] = val;
+        } else {
+          allFilled = false;
+        }
       }
-    } else if (server === "slack") {
-      p.note(
-        [
-          "1. Go to https://api.slack.com/apps",
-          "2. Create a new app > From scratch",
-          "3. Add Bot Token Scopes: channels:read, chat:write",
-          "4. Install to workspace, copy Bot User OAuth Token (xoxb-...)",
-          "5. Get Team ID from workspace URL or Slack settings",
-        ].join("\n"),
-        "Get Slack Token"
-      );
-      const slackToken = guard(await p.password({ message: "Slack Bot Token (xoxb-...)" }));
-      const slackTeam = guard(await p.text({ message: "Slack Team ID" }));
-      if (slackToken && mcpConfig.mcpServers.slack) {
-        mcpConfig.mcpServers.slack.enabled = true;
-        mcpConfig.mcpServers.slack.env.SLACK_BOT_TOKEN = slackToken;
-        mcpConfig.mcpServers.slack.env.SLACK_TEAM_ID = slackTeam;
+      for (const key of headerCredKeys) {
+        const val = guard(await p.password({ message: `${key} for ${serverInfo.label}` }));
+        if (val) {
+          mcpConfig.mcpServers[serverName].headers[key] = val;
+        } else {
+          allFilled = false;
+        }
       }
-    } else if (server === "sentry") {
-      p.note(
-        [
-          "1. Go to https://sentry.io/settings/auth-tokens/",
-          "2. Create a new auth token",
-          "3. Select scopes: project:read, event:read",
-        ].join("\n"),
-        "Get Sentry Token"
-      );
-      const sentryToken = guard(await p.password({ message: "Sentry Auth Token" }));
-      if (sentryToken && mcpConfig.mcpServers.sentry) {
-        mcpConfig.mcpServers.sentry.enabled = true;
-        mcpConfig.mcpServers.sentry.env.SENTRY_AUTH_TOKEN = sentryToken;
+
+      if (allFilled) {
+        mcpConfig.mcpServers[serverName].enabled = true;
+      } else {
+        p.log.warn(`${serverInfo.label}: missing credentials — saved but not enabled`);
       }
     } else {
-      mcpConfig.mcpServers[server].enabled = true;
+      mcpConfig.mcpServers[serverName].enabled = true;
     }
   }
 

package/src/skills/SkillLoader.js

@@ -367,6 +367,34 @@ class SkillLoader {
     return `\n\n## Active Skills\n${sections.join("\n")}`;
   }
 
+  /**
+   * Get a skill by name or path. Supports:
+   *   - Exact name: "coding"
+   *   - Path: "skills/coding.md", "skills/webapp-testing/SKILL.md"
+   *   - Partial path: "coding.md"
+   * Returns full skill object or null.
+   */
+  getSkill(nameOrPath) {
+    if (!this.loaded) this.load();
+    // Direct name lookup
+    if (this.skills.has(nameOrPath)) return this.skills.get(nameOrPath);
+
+    // Strip common path prefixes and .md extension for matching
+    let normalized = nameOrPath
+      .replace(/^skills\//, "")
+      .replace(/\/SKILL\.md$/i, "")
+      .replace(/\.md$/, "");
+
+    if (this.skills.has(normalized)) return this.skills.get(normalized);
+
+    // Case-insensitive fallback
+    const lower = normalized.toLowerCase();
+    for (const [key, skill] of this.skills) {
+      if (key.toLowerCase() === lower) return skill;
+    }
+    return null;
+  }
+
   /**
    * List all loaded skills.
    */

package/src/tools/index.js

@@ -66,7 +66,7 @@ function spawnAgent(taskDescription, optionsJson) {
 }
 
 const spawnAgentDescription =
-  'spawnAgent(taskDescription: string, optionsJson?: string) - Spawn a sub-agent to handle a task independently. optionsJson: {"model":"openai:gpt-4.1-mini","tools":["readFile","searchContent"],"maxTurns":10,"parentContext":"shared spec here"}';
+  'spawnAgent(taskDescription: string, optionsJson?: string) - Spawn a sub-agent to handle a task independently. optionsJson: {"model":"openai:gpt-4.1-mini","tools":["readFile","searchContent"],"skills":["skills/coding.md","skills/brand-guidelines.md"],"parentContext":"shared spec here"}. Pass skills array with paths from the skills list to inject skill content directly into the sub-agent.';
 
 // ─── Wrap parallelAgents for the tool interface ────────────────────────────────
 function parallelAgents(tasksJson, sharedOptionsJson) {

package/src/utils/Embeddings.js

@@ -4,12 +4,15 @@
  * Auto-detects the best available embedding provider (priority order):
  *   1. OPENAI_API_KEY      → text-embedding-3-small  (512 dims)
  *   2. GOOGLE_AI_API_KEY   → text-embedding-004       (768 dims)
- *   3. OLLAMA_HOST         → nomic-embed-text         (768 dims, local/free)
- *   4. Ollama auto-detect  → tries localhost:11434    (no config needed)
- *   5. Built-in TF-IDF     → pure JS, zero deps, zero API calls
+ *   3. Ollama (local)      → all-minilm               (384 dims, auto-pulled)
+ *   4. Built-in TF-IDF     → pure JS, zero deps, zero API calls
+ *
+ * Ollama is the default local embedding engine. On startup, ensureOllamaEmbedModel()
+ * probes localhost:11434, and if Ollama is running but the model isn't pulled, auto-pulls it.
+ * No user configuration needed — just have Ollama installed and running.
  *
  * Override with: EMBEDDING_PROVIDER=openai|google|ollama|tfidf
- * Override Ollama model with: OLLAMA_EMBED_MODEL=nomic-embed-text
+ * Override Ollama model with: OLLAMA_EMBED_MODEL=all-minilm
  *
  * Note: vectors from different providers are NOT interchangeable.
  * Callers (SkillLoader, memory.js) tag stored vectors with the provider name
@@ -19,16 +22,18 @@
 import { embed } from "ai";
 
 let _ollamaAutoDetected = null; // null = untested, true/false = tested
+let _ollamaModelReady = false;  // true once we've confirmed the embed model exists
 
 /**
  * Probe localhost:11434 for a running Ollama instance (one-time check, cached).
  */
 async function _probeOllama() {
   if (_ollamaAutoDetected !== null) return _ollamaAutoDetected;
+  const baseUrl = process.env.OLLAMA_HOST || "http://localhost:11434";
   try {
     const ctrl = new AbortController();
-    const timer = setTimeout(() => ctrl.abort(), 1500);
-    const res = await fetch("http://localhost:11434/api/tags", { signal: ctrl.signal });
+    const timer = setTimeout(() => ctrl.abort(), 2000);
+    const res = await fetch(`${baseUrl}/api/tags`, { signal: ctrl.signal });
     clearTimeout(timer);
     _ollamaAutoDetected = res.ok;
   } catch {
@@ -37,6 +42,75 @@ async function _probeOllama() {
   return _ollamaAutoDetected;
 }
 
+/**
+ * Check if a specific model is available in Ollama. If not, pull it.
+ * Called once at startup — non-blocking background pull.
+ */
+async function _ensureOllamaModel(modelName) {
+  if (_ollamaModelReady) return true;
+  const baseUrl = process.env.OLLAMA_HOST || "http://localhost:11434";
+
+  try {
+    // Check if model already exists
+    const tagsRes = await fetch(`${baseUrl}/api/tags`);
+    if (!tagsRes.ok) return false;
+    const tags = await tagsRes.json();
+    const models = tags.models || [];
+    const exists = models.some(m =>
+      m.name === modelName || m.name === `${modelName}:latest` || m.name.startsWith(`${modelName}:`)
+    );
+
+    if (exists) {
+      _ollamaModelReady = true;
+      return true;
+    }
+
+    // Model not found — pull it
+    console.log(`[Embeddings] Pulling Ollama model "${modelName}" for embeddings (one-time)...`);
+    const pullRes = await fetch(`${baseUrl}/api/pull`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: modelName, stream: false }),
+    });
+
+    if (pullRes.ok) {
+      console.log(`[Embeddings] Successfully pulled "${modelName}"`);
+      _ollamaModelReady = true;
+      return true;
+    } else {
+      const err = await pullRes.text().catch(() => "unknown error");
+      console.log(`[Embeddings] Failed to pull "${modelName}": ${err}`);
+      return false;
+    }
+  } catch (e) {
+    console.log(`[Embeddings] Ollama model check failed: ${e.message}`);
+    return false;
+  }
+}
+
+/**
+ * Initialize Ollama embedding model on startup.
+ * Call this once — it probes Ollama and auto-pulls the embed model if needed.
+ * Non-blocking, fire-and-forget safe.
+ */
+export async function ensureOllamaEmbedModel() {
+  // Skip if user explicitly chose a different provider
+  const override = process.env.EMBEDDING_PROVIDER?.toLowerCase();
+  if (override && override !== "ollama") return;
+
+  // Skip if OpenAI or Google keys are set (they take priority)
+  if (process.env.OPENAI_API_KEY || process.env.GOOGLE_AI_API_KEY) return;
+
+  const ollamaAvailable = await _probeOllama();
+  if (!ollamaAvailable) {
+    console.log("[Embeddings] Ollama not detected — using TF-IDF for embeddings");
+    return;
+  }
+
+  const modelName = process.env.OLLAMA_EMBED_MODEL || "all-minilm";
+  await _ensureOllamaModel(modelName);
+}
+
 /**
  * Returns the currently active embedding provider name, or null if none available.
  * Sync version — returns "ollama-auto" when auto-detect is pending (caller must handle).
@@ -56,7 +130,7 @@ export function getEmbeddingProvider() {
   if (process.env.OPENAI_API_KEY)    return "openai";
   if (process.env.GOOGLE_AI_API_KEY) return "google";
   if (process.env.OLLAMA_HOST)       return "ollama";
-  // Ollama auto-detect result (set after first generateEmbedding call)
+  // Ollama auto-detect result (set after first generateEmbedding call or ensureOllamaEmbedModel)
   if (_ollamaAutoDetected === true)  return "ollama";
   // Always available — built-in TF-IDF as last resort
   return "tfidf";
@@ -85,6 +159,9 @@ export async function getEmbeddingProviderAsync() {
     const found = await _probeOllama();
     if (found) {
       console.log("[Embeddings] Auto-detected Ollama at localhost:11434");
+      // Also ensure the embed model is pulled
+      const modelName = process.env.OLLAMA_EMBED_MODEL || "all-minilm";
+      await _ensureOllamaModel(modelName);
       return "ollama";
     }
   } else if (_ollamaAutoDetected) {