mulmoclaude 0.1.2 → 0.3.0

package/src/utils/format/frontmatter.ts

@@ -66,15 +66,15 @@ function parseValue(raw: string): FrontmatterValue {
   if (arrayMatch) {
     return arrayMatch[1]
       .split(",")
-      .map((s) => unquote(s.trim()))
-      .filter((s) => s.length > 0);
+      .map((item) => unquote(item.trim()))
+      .filter((item) => item.length > 0);
   }
   return unquote(raw);
 }
 
-function unquote(s: string): string {
-  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
-    return s.slice(1, -1);
+function unquote(str: string): string {
+  if ((str.startsWith('"') && str.endsWith('"')) || (str.startsWith("'") && str.endsWith("'"))) {
+    return str.slice(1, -1);
   }
-  return s;
+  return str;
 }

package/src/utils/image/rewriteMarkdownImageRefs.ts

@@ -51,7 +51,7 @@ function shouldSkip(url: string): boolean {
 function resolveWorkspacePath(basePath: string, url: string): string | null {
   // Absolute-within-workspace (e.g. "/images/foo.png") — reset base.
   const isAbsolute = url.startsWith("/");
-  const baseSegs = isAbsolute ? [] : basePath.split("/").filter((s) => s !== "" && s !== ".");
+  const baseSegs = isAbsolute ? [] : basePath.split("/").filter((seg) => seg !== "" && seg !== ".");
   const segs = [...baseSegs];
 
   const urlSegs = (isAbsolute ? url.slice(1) : url).split("/");
@@ -76,9 +76,9 @@ function extractBracketedAlt(raw: string): string | null {
   if (!raw.startsWith("![")) return null;
   let depth = 1;
   for (let i = 2; i < raw.length; i++) {
-    const c = raw[i];
-    if (c === "[") depth++;
-    else if (c === "]") {
+    const char = raw[i];
+    if (char === "[") depth++;
+    else if (char === "]") {
       depth--;
       if (depth === 0) return raw.slice(2, i);
     }
@@ -123,7 +123,7 @@ function getContainerChildren(token: Token): Token[] | null {
 // Returns true if the container was rendered via its children, false
 // if the caller should fall back to emitting the parent's raw.
 function renderContainerChildren(raw: string, children: Token[], basePath: string, out: string[]): boolean {
-  const joined = children.map((c) => (c as { raw?: string }).raw ?? "").join("");
+  const joined = children.map((token) => (token as { raw?: string }).raw ?? "").join("");
   if (joined === "") return false;
   const idx = raw.indexOf(joined);
   if (idx < 0) return false;

package/src/utils/markdown/extractFirstH1.ts

@@ -30,8 +30,8 @@ export function extractFirstH1(markdown: string): string | null {
   return null;
 }
 
-function splitLines(s: string): string[] {
-  return s.split(/\r\n|\r|\n/);
+function splitLines(str: string): string[] {
+  return str.split(/\r\n|\r|\n/);
 }
 
 function isInlineSpace(code: number): boolean {

package/src/utils/path/relativeLink.ts

@@ -73,13 +73,13 @@ export function resolveWorkspaceLink(currentFilePath: string, href: string): str
 
 // Drop any trailing #fragment or ?query from a path-like string.
 // Whichever marker comes first wins.
-function stripFragmentAndQuery(s: string): string {
-  const hashIdx = s.indexOf("#");
-  const queryIdx = s.indexOf("?");
-  let end = s.length;
+function stripFragmentAndQuery(str: string): string {
+  const hashIdx = str.indexOf("#");
+  const queryIdx = str.indexOf("?");
+  let end = str.length;
   if (hashIdx !== -1 && hashIdx < end) end = hashIdx;
   if (queryIdx !== -1 && queryIdx < end) end = queryIdx;
-  return s.slice(0, end);
+  return str.slice(0, end);
 }
 
 // If `resolvedPath` points at a chat session log (e.g.
@@ -95,26 +95,26 @@ export function extractSessionIdFromPath(resolvedPath: string): string | null {
   const JSONL_SUFFIX = ".jsonl";
   if (!resolvedPath.startsWith(CHAT_PREFIX)) return null;
   if (!resolvedPath.endsWith(JSONL_SUFFIX)) return null;
-  const id = resolvedPath.slice(CHAT_PREFIX.length, resolvedPath.length - JSONL_SUFFIX.length);
-  if (id.length === 0) return null;
-  if (id.includes("/")) return null;
-  return id;
+  const sessionId = resolvedPath.slice(CHAT_PREFIX.length, resolvedPath.length - JSONL_SUFFIX.length);
+  if (sessionId.length === 0) return null;
+  if (sessionId.includes("/")) return null;
+  return sessionId;
 }
 
 // POSIX-style dirname. The file viewer always uses "/" separators
 // so we don't need to worry about Windows paths.
-function posixDirname(p: string): string {
-  const i = p.lastIndexOf("/");
-  return i === -1 ? "" : p.slice(0, i);
+function posixDirname(path: string): string {
+  const i = path.lastIndexOf("/");
+  return i === -1 ? "" : path.slice(0, i);
 }
 
 // Collapse "./" and "../" in a workspace path. Rejects paths that
 // escape above the workspace root. Returns null for the empty-path
 // case so the caller can bail out. Callers are expected to strip
 // #fragment / ?query before invoking this function.
-function normalizeWorkspacePath(p: string): string | null {
-  if (p.length === 0) return null;
-  const parts = p.split("/");
+function normalizeWorkspacePath(path: string): string | null {
+  if (path.length === 0) return null;
+  const parts = path.split("/");
   const stack: string[] = [];
   for (const part of parts) {
     if (part === "" || part === ".") continue;

package/src/utils/role/icon.ts

@@ -11,10 +11,10 @@ import type { Role } from "../../config/roles";
 const MATERIAL_ICON_RE = /^[a-z_]+$/;
 
 export function roleIcon(roles: Role[], roleId: string): string {
-  const icon = roles.find((r) => r.id === roleId)?.icon ?? "star";
+  const icon = roles.find((role) => role.id === roleId)?.icon ?? "star";
   return MATERIAL_ICON_RE.test(icon) ? icon : "smart_toy";
 }
 
 export function roleName(roles: Role[], roleId: string): string {
-  return roles.find((r) => r.id === roleId)?.name ?? roleId;
+  return roles.find((role) => role.id === roleId)?.name ?? roleId;
 }

package/src/utils/role/merge.ts

@@ -5,6 +5,6 @@
 import type { Role } from "../../config/roles";
 
 export function mergeRoles(builtin: Role[], custom: Role[]): Role[] {
-  const customIds = new Set(custom.map((r) => r.id));
-  return [...builtin.filter((r) => !customIds.has(r.id)), ...custom];
+  const customIds = new Set(custom.map((role) => role.id));
+  return [...builtin.filter((role) => !customIds.has(role.id)), ...custom];
 }

package/src/utils/role/plugins.ts

@@ -8,5 +8,5 @@ const GEMINI_PLUGINS = new Set<ToolName>([TOOL_NAMES.generateImage, TOOL_NAMES.p
 
 /** Whether the given role uses any plugin that requires a Gemini API key. */
 export function needsGemini(roles: Role[], roleId: string): boolean {
-  return (roles.find((r) => r.id === roleId)?.availablePlugins ?? []).some((p) => GEMINI_PLUGINS.has(p));
+  return (roles.find((role) => role.id === roleId)?.availablePlugins ?? []).some((plugin) => GEMINI_PLUGINS.has(plugin));
 }

package/src/utils/session/sessionFactory.ts

@@ -2,10 +2,10 @@
 
 import type { ActiveSession } from "../../types/session";
 
-export function createEmptySession(id: string, roleId: string): ActiveSession {
+export function createEmptySession(sessionId: string, roleId: string): ActiveSession {
   const now = new Date().toISOString();
   return {
-    id,
+    id: sessionId,
     roleId,
     toolResults: [],
     resultTimestamps: new Map(),

package/src/utils/session/sessionHelpers.ts

@@ -79,7 +79,7 @@ export function applyTextEvent(session: ActiveSession, message: string, source:
 /** In-place update a result that was re-emitted by a plugin view
  *  (e.g. after the user edits a chart config). */
 export function updateResult(session: ActiveSession, updatedResult: ToolResultComplete): void {
-  const index = session.toolResults.findIndex((r) => r.uuid === updatedResult.uuid);
+  const index = session.toolResults.findIndex((result) => result.uuid === updatedResult.uuid);
   if (index !== -1) {
     Object.assign(session.toolResults[index], updatedResult);
   }
@@ -89,7 +89,7 @@ export function updateResult(session: ActiveSession, updatedResult: ToolResultCo
  *  result list. Selects the result only on insert; in-place updates
  *  preserve the user's current selection. */
 export function applyToolResultToSession(session: ActiveSession, result: ToolResultComplete): void {
-  const idx = session.toolResults.findIndex((r) => r.uuid === result.uuid);
+  const idx = session.toolResults.findIndex((existing) => existing.uuid === result.uuid);
   if (idx >= 0) {
     session.toolResults[idx] = result;
   } else {

package/src/utils/tools/dedup.ts

@@ -7,11 +7,11 @@
 import type { ToolResultComplete } from "gui-chat-protocol/vue";
 
 export function deduplicateResults(all: ToolResultComplete[]): ToolResultComplete[] {
-  return all.filter((r, i) => {
-    if (r.toolName === "text-response") return true;
+  return all.filter((result, i) => {
+    if (result.toolName === "text-response") return true;
     const next = all[i + 1];
     if (!next) return true;
-    if (next.toolName !== r.toolName) return true;
-    return !(r.updating === true && next.updating === true);
+    if (next.toolName !== result.toolName) return true;
+    return !(result.updating === true && next.updating === true);
   });
 }

package/src/utils/tools/result.ts

@@ -9,9 +9,9 @@ import { isRecord } from "../types";
 // Type guard: a text-response entry whose `data.role` is `"user"`.
 // Used by App.vue to find the first user message in a live session
 // when building the merged history list.
-export function isUserTextResponse(r: ToolResultComplete): boolean {
-  if (r.toolName !== "text-response") return false;
-  const data = r.data;
+export function isUserTextResponse(res: ToolResultComplete): boolean {
+  if (res.toolName !== "text-response") return false;
+  const data = res.data;
   if (!isRecord(data)) return false;
   return data.role === "user";
 }

package/src/utils/types.ts

@@ -20,12 +20,12 @@ export function isNonEmptyString(value: unknown): value is string {
 /** Record whose values are all strings. */
 export function isStringRecord(value: unknown): value is Record<string, string> {
   if (!isRecord(value)) return false;
-  return Object.values(value).every((v) => typeof v === "string");
+  return Object.values(value).every((val) => typeof val === "string");
 }
 
 /** String array (every element is a string). */
 export function isStringArray(value: unknown): value is string[] {
-  return Array.isArray(value) && value.every((v) => typeof v === "string");
+  return Array.isArray(value) && value.every((val) => typeof val === "string");
 }
 
 /** Error-like object with a `code` property. */