npm - @rubytech/taskmaster - Versions diffs - 1.0.39 → 1.0.40 - Mend

@rubytech/taskmaster 1.0.39 → 1.0.40

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/dist/build-info.json +3 -3
package/dist/control-ui/assets/index-BfV0Mtl7.css +1 -0
package/dist/control-ui/assets/{index-gQeHDI6a.js → index-RlAacvDz.js} +246 -192
package/dist/control-ui/assets/index-RlAacvDz.js.map +1 -0
package/dist/control-ui/index.html +2 -2
package/dist/gateway/server-methods/memory.js +36 -0
package/dist/memory/hybrid.js +28 -1
package/dist/memory/internal.js +136 -47
package/dist/memory/manager.js +6 -2
package/package.json +1 -1
package/taskmaster-docs/USER-GUIDE.md +51 -8
package/dist/control-ui/assets/index-Ceb3FTmS.css +0 -1
package/dist/control-ui/assets/index-gQeHDI6a.js.map +0 -1

package/dist/control-ui/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <title>Taskmaster Control</title>
     <meta name="color-scheme" content="dark light" />
     <link rel="icon" type="image/png" href="./favicon.png" />
-    <script type="module" crossorigin src="./assets/index-gQeHDI6a.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-Ceb3FTmS.css">
+    <script type="module" crossorigin src="./assets/index-RlAacvDz.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-BfV0Mtl7.css">
   </head>
   <body>
     <taskmaster-app></taskmaster-app>

package/dist/gateway/server-methods/memory.js CHANGED Viewed

@@ -74,6 +74,42 @@ export const memoryHandlers = {
             respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, String(err)));
         }
     },
+    "memory.search": async ({ params, respond }) => {
+        const query = typeof params.query === "string" ? params.query.trim() : "";
+        if (!query) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "query is required"));
+            return;
+        }
+        const cfg = loadConfig();
+        const agentId = typeof params.agentId === "string" && params.agentId.trim()
+            ? params.agentId.trim()
+            : resolveDefaultAgentId(cfg);
+        const { manager, error } = await getMemorySearchManager({ cfg, agentId });
+        if (!manager) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, error ?? "memory index unavailable"));
+            return;
+        }
+        try {
+            const maxResults = typeof params.maxResults === "number" ? params.maxResults : 10;
+            // minScore: 0 — show all results for diagnostic purposes
+            const results = await manager.search(query, { maxResults, minScore: 0 });
+            respond(true, {
+                ok: true,
+                agentId,
+                results: results.map((r) => ({
+                    path: r.path,
+                    startLine: r.startLine,
+                    endLine: r.endLine,
+                    score: r.score,
+                    snippet: r.snippet,
+                    source: r.source,
+                })),
+            });
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, String(err)));
+        }
+    },
     "memory.auditClear": async ({ params, respond }) => {
         try {
             const cfg = loadConfig();

package/dist/memory/hybrid.js CHANGED Viewed

@@ -12,6 +12,32 @@ export function bm25RankToScore(rank) {
     const normalized = Number.isFinite(rank) ? Math.max(0, rank) : 999;
     return 1 / (1 + normalized);
 }
+/**
+ * Path-based boost factors applied during hybrid merge.
+ * Curated knowledge (public/, shared/, root memory files) is boosted over
+ * raw logs (conversations/, session transcripts) so authoritative content
+ * outranks casual mentions at similar raw scores.
+ *
+ * Patterns are checked in order — first match wins.
+ */
+const PATH_BOOST_RULES = [
+    // Conversation archives — demote (high volume, low signal-to-noise)
+    { pattern: /\/conversations\//, boost: 0.6 },
+    // Session source transcripts — demote
+    { pattern: /^sessions\//, boost: 0.6 },
+    // Curated public/shared knowledge — boost
+    { pattern: /^memory\/public\//, boost: 1.4 },
+    { pattern: /^memory\/shared\//, boost: 1.3 },
+    // Root memory files (MEMORY.md etc.) — slight boost
+    { pattern: /^(?:MEMORY|memory)\.md$/, boost: 1.2 },
+];
+function pathBoost(filePath) {
+    for (const rule of PATH_BOOST_RULES) {
+        if (rule.pattern.test(filePath))
+            return rule.boost;
+    }
+    return 1.0;
+}
 export function mergeHybridResults(params) {
     const byId = new Map();
     for (const r of params.vector) {
@@ -47,7 +73,8 @@ export function mergeHybridResults(params) {
         }
     }
     const merged = Array.from(byId.values()).map((entry) => {
-        const score = params.vectorWeight * entry.vectorScore + params.textWeight * entry.textScore;
+        const raw = params.vectorWeight * entry.vectorScore + params.textWeight * entry.textScore;
+        const score = raw * pathBoost(entry.path);
         return {
             path: entry.path,
             startLine: entry.startLine,

package/dist/memory/internal.js CHANGED Viewed

@@ -89,77 +89,166 @@ export async function buildFileEntry(absPath, workspaceDir) {
         hash,
     };
 }
-export function chunkMarkdown(content, chunking) {
-    const lines = content.split("\n");
-    if (lines.length === 0)
+/**
+ * Heading level (1-6) parsed from a markdown heading line, or 0 if not a heading.
+ */
+function headingLevel(line) {
+    const match = line.match(/^(#{1,6})\s/);
+    return match ? match[1].length : 0;
+}
+/**
+ * Build a heading breadcrumb prefix from the current heading stack.
+ * E.g., ["# User Guide", "## Updating Taskmaster"] → "# User Guide > ## Updating Taskmaster"
+ */
+function headingPrefix(stack) {
+    const filtered = stack.filter(Boolean);
+    return filtered.length > 0 ? filtered.join(" > ") + "\n" : "";
+}
+/**
+ * Split lines into fixed-size chunks (the original algorithm).
+ * Used as a fallback when a single section exceeds maxChars.
+ */
+function chunkLinesFixed(entries, maxChars, prefix) {
+    if (entries.length === 0)
         return [];
-    const maxChars = Math.max(32, chunking.tokens * 4);
-    const overlapChars = Math.max(0, chunking.overlap * 4);
+    const prefixLen = prefix.length;
+    const effectiveMax = Math.max(32, maxChars - prefixLen);
     const chunks = [];
     let current = [];
     let currentChars = 0;
     const flush = () => {
         if (current.length === 0)
             return;
-        const firstEntry = current[0];
-        const lastEntry = current[current.length - 1];
-        if (!firstEntry || !lastEntry)
-            return;
-        const text = current.map((entry) => entry.line).join("\n");
-        const startLine = firstEntry.lineNo;
-        const endLine = lastEntry.lineNo;
+        const first = current[0];
+        const last = current[current.length - 1];
+        const body = current.map((e) => e.line).join("\n");
+        const text = prefix + body;
         chunks.push({
-            startLine,
-            endLine,
+            startLine: first.lineNo,
+            endLine: last.lineNo,
             text,
             hash: hashText(text),
         });
     };
-    const carryOverlap = () => {
-        if (overlapChars <= 0 || current.length === 0) {
-            current = [];
-            currentChars = 0;
-            return;
-        }
-        let acc = 0;
-        const kept = [];
-        for (let i = current.length - 1; i >= 0; i -= 1) {
-            const entry = current[i];
-            if (!entry)
-                continue;
-            acc += entry.line.length + 1;
-            kept.unshift(entry);
-            if (acc >= overlapChars)
-                break;
-        }
-        current = kept;
-        currentChars = kept.reduce((sum, entry) => sum + entry.line.length + 1, 0);
-    };
-    for (let i = 0; i < lines.length; i += 1) {
-        const line = lines[i] ?? "";
-        const lineNo = i + 1;
+    for (const entry of entries) {
+        // Split overly long lines into segments that fit within effectiveMax
         const segments = [];
-        if (line.length === 0) {
-            segments.push("");
+        if (entry.line.length === 0) {
+            segments.push(entry);
         }
         else {
-            for (let start = 0; start < line.length; start += maxChars) {
-                segments.push(line.slice(start, start + maxChars));
+            for (let start = 0; start < entry.line.length; start += effectiveMax) {
+                segments.push({
+                    line: entry.line.slice(start, start + effectiveMax),
+                    lineNo: entry.lineNo,
+                });
             }
         }
-        for (const segment of segments) {
-            const lineSize = segment.length + 1;
-            if (currentChars + lineSize > maxChars && current.length > 0) {
+        for (const seg of segments) {
+            const segSize = seg.line.length + 1;
+            if (currentChars + segSize > effectiveMax && current.length > 0) {
                 flush();
-                carryOverlap();
+                current = [];
+                currentChars = 0;
             }
-            current.push({ line: segment, lineNo });
-            currentChars += lineSize;
+            current.push(seg);
+            currentChars += segSize;
         }
     }
     flush();
     return chunks;
 }
+/**
+ * Semantic markdown chunker.
+ *
+ * Splits content at markdown headings so each chunk corresponds to a logical section.
+ * Each chunk is prefixed with the heading breadcrumb (ancestor headings) so the embedding
+ * model has structural context — e.g., "# User Guide > ## Updating Taskmaster\n...content...".
+ *
+ * If a section exceeds maxChars, it falls back to fixed-size splitting within that section,
+ * but each sub-chunk still receives the heading prefix.
+ *
+ * Files with no headings are chunked using fixed-size splitting (original behavior).
+ */
+export function chunkMarkdown(content, chunking) {
+    if (!content.trim())
+        return [];
+    const lines = content.split("\n");
+    const maxChars = Math.max(32, chunking.tokens * 4);
+    // Parse all lines to detect if there are any headings
+    const parsedLines = [];
+    let hasHeadings = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        const level = headingLevel(line);
+        if (level > 0)
+            hasHeadings = true;
+        parsedLines.push({ line, lineNo: i + 1, level });
+    }
+    // No headings at all — fall back to fixed-size chunking (no prefix)
+    if (!hasHeadings) {
+        return chunkLinesFixed(parsedLines.map((p) => ({ line: p.line, lineNo: p.lineNo })), maxChars, "");
+    }
+    const sections = [];
+    // headingStack tracks the current heading hierarchy: index = level-1
+    const headingStack = [];
+    let currentSection = { headingStack: [], lines: [] };
+    for (const parsed of parsedLines) {
+        if (parsed.level > 0) {
+            // Flush the previous section if it has content
+            if (currentSection.lines.length > 0) {
+                sections.push(currentSection);
+            }
+            // Update the heading stack: trim to this level, then set this heading.
+            // Use splice to avoid sparse arrays (setting .length on a shorter array
+            // leaves undefined holes when the heading appears without ancestors).
+            if (headingStack.length >= parsed.level) {
+                headingStack.length = parsed.level - 1;
+            }
+            headingStack[parsed.level - 1] = parsed.line;
+            // Start a new section with the current heading stack as context
+            currentSection = {
+                headingStack: [...headingStack],
+                lines: [{ line: parsed.line, lineNo: parsed.lineNo }],
+            };
+        }
+        else {
+            currentSection.lines.push({ line: parsed.line, lineNo: parsed.lineNo });
+        }
+    }
+    // Flush final section
+    if (currentSection.lines.length > 0) {
+        sections.push(currentSection);
+    }
+    // Convert sections to chunks
+    const chunks = [];
+    for (const section of sections) {
+        // Build the prefix from ancestor headings (all except the current heading,
+        // which is already the first line of the section body)
+        const ancestors = section.headingStack.slice(0, -1);
+        const prefix = headingPrefix(ancestors);
+        const bodyText = section.lines.map((e) => e.line).join("\n");
+        const totalLen = prefix.length + bodyText.length;
+        if (totalLen <= maxChars) {
+            // Section fits in one chunk
+            const first = section.lines[0];
+            const last = section.lines[section.lines.length - 1];
+            const text = prefix + bodyText;
+            chunks.push({
+                startLine: first.lineNo,
+                endLine: last.lineNo,
+                text,
+                hash: hashText(text),
+            });
+        }
+        else {
+            // Section too large — split with fixed-size chunking, each sub-chunk gets prefix
+            const subChunks = chunkLinesFixed(section.lines, maxChars, prefix);
+            chunks.push(...subChunks);
+        }
+    }
+    return chunks;
+}
 export function parseEmbedding(raw) {
     try {
         const parsed = JSON.parse(raw);

package/dist/memory/manager.js CHANGED Viewed

@@ -1367,8 +1367,12 @@ export class MemoryIndexManager {
             const shouldSyncMemory = this.sources.has("memory") && (params?.force || needsFullReindex || this.dirty);
             const shouldSyncSessions = this.shouldSyncSessions(params, needsFullReindex);
             if (shouldSyncMemory) {
-                await this.syncMemoryFiles({ needsFullReindex, progress: progress ?? undefined });
-                this.dirty = false;
+                try {
+                    await this.syncMemoryFiles({ needsFullReindex, progress: progress ?? undefined });
+                }
+                finally {
+                    this.dirty = false;
+                }
             }
             if (shouldSyncSessions) {
                 await this.syncSessionFiles({ needsFullReindex, progress: progress ?? undefined });

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/taskmaster",
-  "version": "1.0.39",
+  "version": "1.0.40",
   "description": "AI-powered business assistant for small businesses",
   "publishConfig": {
     "access": "public"

package/taskmaster-docs/USER-GUIDE.md CHANGED Viewed

@@ -495,6 +495,18 @@ When you add or change a file, your assistant picks it up automatically — no r
 When your assistant writes to **public/** or **shared/**, a shield icon appears in the navigation bar so you can review what was written (see [Data Safety Alert](#data-safety-alert) above).
+### Searching Memory
+The Files page includes a **memory search bar** that lets you test what your assistant finds when it searches its knowledge base.
+1. Type a query in the **Search memory** box and press Enter (or click **Search**)
+2. Results show the file path, relevance score (as a percentage), matching line numbers, and a snippet of the matched text
+3. Click any result to open the file preview
+4. Use the **agent selector** dropdown next to the search bar to switch between agents (e.g., public vs admin) — this lets you verify what each assistant can see
+5. Click **Clear** to return to the normal file tree view
+This is useful for diagnosing search issues — if your assistant can't find something in conversation, test the same query here to see what comes back. All results are shown regardless of score threshold, so you can see everything the search engine found.
 ---
 ## Status Dashboard
@@ -952,19 +964,50 @@ Only the business owner can change the activation mode.
 ## Updating Taskmaster
-When a new version of Taskmaster is available, the **Software** row on the Status Dashboard turns yellow and shows the new version number (e.g., "v1.2.3 → v1.3.0").
+### Checking for Updates
+Taskmaster checks for updates automatically when you open the Setup page. The **Software** row in the Status Dashboard shows your current version and whether an update is available:
-To update:
+- **Green** — You're running the latest version
+- **Yellow** — An update is available (shows the new version number, e.g., "v1.0.38 → v1.0.39")
+- **Grey** — Not yet checked
+If the row shows "Unknown", tap the **refresh** button (circular arrow) to check manually. Tap the **(i)** button to see version details (current version, latest version, and status).
+### Installing an Update
 1. Open the **Setup** page
-2. Look for the **Software** row in the dashboard
-3. If an update is available, tap the **download** button (down-arrow icon)
-4. Wait for the update to complete — the page will reload automatically
-5. After reload, the Software row should show "Up to date" in green
+2. Look for the **Software** row — if it's yellow, an update is available
+3. Tap the **download** button (down-arrow icon)
+4. A progress overlay appears showing each step of the update (fetching, building, running checks, etc.)
+5. When the update completes, the gateway restarts automatically
+6. The page reconnects on its own — you'll see a result banner showing the version change (e.g., "Updated: v1.0.38 → v1.0.39")
+7. The Software row should now show green
+You don't need to refresh the page — the overlay stays visible during the update and the page reconnects automatically after the gateway restarts.
+### Alternative: Re-run the Installer
+You can also update by re-running the install command in Terminal:
+```bash
+curl -fsSL https://taskmaster.bot/install.sh | bash
+```
+This detects your existing installation and upgrades it in place.
+### If an Update Fails
+If something goes wrong during the update:
+- The progress overlay shows which step failed (marked with an X)
+- A result banner appears with the failure reason
+- Your previous version remains running — a failed update does not leave your system broken
+- Tap **Dismiss** to close the result banner
-If the Software row shows "Unknown", tap the **refresh** button (circular arrow) to check for updates. Tap the **(i)** button to see version details.
+If the page loses connection during the update and doesn't reconnect within two minutes, refresh the page manually. If the gateway doesn't come back, try power-cycling your device (unplug and replug).
-> **Note:** Updates require an internet connection. The update process takes about 30 seconds. Your assistant will be briefly unavailable during the restart.
+> **Note:** Updates require an internet connection. The update process typically takes 30–60 seconds. Your assistant will be briefly unavailable during the restart.
 ---