@zythum02/fello-server 0.1.39 → 0.1.45

package/out/scripts/mcp-memory/server.mjs

@@ -0,0 +1,183 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import * as fs from "fs";
+import * as http from "http";
+const memoryQueryRequestSchema = z.object({
+  query: z.string().min(1).optional().describe(
+    "Focused topic to retrieve. Required for every specific task, question, recommendation, or domain discussion; never omit it merely to discover whether relevant memories exist. Omit only when a broad project-memory briefing is genuinely needed."
+  )
+});
+const memoryQueryRespondSchema = z.object({
+  content: z.string().describe("The generated project briefing or relevant memory details.")
+});
+const memoryStoreRequestSchema = z.object({
+  facts: z.array(
+    z.object({
+      text: z.string().max(512).describe("The fact to remember, concise and self-contained."),
+      reason: z.string().max(300).optional().describe(
+        "Why this should be remembered — context that helps determine weight and tags (e.g. if the user strongly emphasized it or corrected the agent)."
+      )
+    })
+  ).min(1).max(10).describe(
+    "Facts to remember. The system will organize, deduplicate, and assign priority in the background."
+  )
+});
+const memoryStoreRespondSchema = z.object({
+  stored: z.number().describe("Number of facts submitted for integration."),
+  message: z.string().optional().describe("Brief confirmation of the memory operation.")
+});
+function getArg(name) {
+  const idx = process.argv.indexOf(`--${name}`);
+  return idx !== -1 ? process.argv[idx + 1] : void 0;
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function loadCriticalMemories(filePath) {
+  if (!filePath) return [];
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "string") : [];
+  } catch (error) {
+    console.error(`[mcp-memory] Failed to load critical memories: ${getErrorMessage(error)}`);
+    return [];
+  } finally {
+    fs.rmSync(filePath, { force: true });
+  }
+}
+const socketPath = getArg("socket-path");
+const criticalMemories = loadCriticalMemories(getArg("critical-memory"));
+if (!socketPath) {
+  console.error("[mcp-memory] Missing required argument: --socket-path");
+  process.exit(1);
+}
+const criticalMemoryDescription = criticalMemories.length === 0 ? "" : `
+
+Automatically loaded critical project memories — always follow these:
+${criticalMemories.map((memory) => `- ${memory.replaceAll("\n", "\n  ")}`).join("\n")}
+
+These are only the highest-priority project constraints, not the complete project memory. Do not treat the absence of a detail here as evidence that no relevant memory exists. This list does not replace task-specific retrieval.`;
+const server = new McpServer({
+  name: "Memory",
+  version: "1.0.0",
+  description: "Provides memory_query and memory_store tools for persistent project-level memory."
+});
+server.registerTool(
+  "memory_query",
+  {
+    description: `Query the project's persistent memory.${criticalMemoryDescription}
+
+For every specific task, question, recommendation, or domain discussion that may depend on memory, provide a focused query. Include all relevant dimensions in that query, such as applicable conventions, preferences, decisions, corrections, architecture, or commands.
+
+Never omit query merely to discover whether relevant memories exist. Omit it only when a broad project-memory briefing is genuinely needed, such as when the user asks what is remembered.
+
+A focused query returns relevant details. An omitted query generates a current summary from the stored entries. In either mode, memories included in the response are marked as used.`,
+    inputSchema: memoryQueryRequestSchema
+  },
+  async (input) => {
+    try {
+      const result = memoryQueryRespondSchema.parse(await postToSocket("/memory/query", input));
+      return {
+        content: [
+          {
+            type: "text",
+            text: result.content || "(no project memories stored yet)"
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          { type: "text", text: `Error querying memory: ${getErrorMessage(error)}` }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.registerTool(
+  "memory_store",
+  {
+    description: `Store facts into persistent project memory for future sessions.
+
+Proactively store facts worth remembering for future sessions. Common triggers:
+- User states a preference, makes a choice, or corrects your behavior (even subtly)
+- You discover a project convention, tech stack detail, or architectural decision
+- User emphasizes something with "always", "never", "remember", "一定", "不要"
+- User explicitly asks you to remember something
+
+Also store when:
+- User explains why they do something a certain way
+- User mentions a tool, framework, or library choice
+- You make a decision during the conversation that affects future work
+- User tells you to skip or avoid something
+
+When in doubt about whether to store — store it. Forgetting costs more than duplicating.
+
+Each fact should be a concise, self-contained statement. Include a reason when the context helps determine importance (e.g. if the user strongly emphasized it or corrected the agent).`,
+    inputSchema: memoryStoreRequestSchema
+  },
+  async (input) => {
+    try {
+      const result = memoryStoreRespondSchema.parse(await postToSocket("/memory/store", input));
+      return {
+        content: [
+          {
+            type: "text",
+            text: result.message || `Stored ${result.stored} fact(s) to project memory.`
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          { type: "text", text: `Error storing memory: ${getErrorMessage(error)}` }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+function postToSocket(path, body) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const options = {
+      socketPath,
+      path,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(data)
+      }
+    };
+    const req = http.request(options, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        const raw = Buffer.concat(chunks).toString("utf8");
+        try {
+          const parsed = JSON.parse(raw);
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(parsed);
+          } else {
+            const message = typeof parsed === "object" && parsed && "error" in parsed ? String(parsed.error) : `HTTP ${res.statusCode}: ${raw}`;
+            reject(new Error(message));
+          }
+        } catch {
+          reject(new Error(`Invalid response (${res.statusCode}): ${raw}`));
+        }
+      });
+    });
+    req.on("error", (error) => {
+      reject(new Error(`Socket request failed: ${error.message}`));
+    });
+    req.write(data);
+    req.end();
+  });
+}
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch(console.error);

package/out/scripts/mcp-search/server.mjs

@@ -161,7 +161,7 @@ Uses tree-sitter WASM parsing to extract function/class/interface/type/property
 Returns tree-structured metadata only - no code body is included.
 Use this first before ReadFile to understand a file's structure.
 
-Supports: TypeScript (.ts), JavaScript/JSX (.js/.jsx/.mjs/.cjs), TSX (.tsx), Python (.py), Go (.go), C (.c/.h), C++ (.cpp/.cc/.cxx/.hpp/.hxx/.hh), Swift (.swift), Kotlin (.kt/.kts), Markdown (.md/.mdx/.markdown).
+Supports: TypeScript (.ts), JavaScript/JSX (.js/.jsx/.mjs/.cjs), TSX (.tsx), Python (.py), Go (.go), C (.c/.h), C++ (.cpp/.cc/.cxx/.hpp/.hxx/.hh), Swift (.swift), Kotlin (.kt/.kts), Dart (.dart), Markdown (.md/.mdx/.markdown).
 
 The path parameter accepts:
 - Relative path (relative to project root): "src/app.ts", "./lib/utils.ts"

package/out/scripts/mcp-toolbox/server.mjs

@@ -0,0 +1,482 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import * as http from "http";
+const base64EncodeRequestSchema = z.object({
+  text: z.string().describe("The text string to encode into Base64.")
+});
+const base64EncodeRespondSchema = z.object({
+  result: z.string()
+});
+const base64DecodeRequestSchema = z.object({
+  base64: z.string().describe("The Base64-encoded string to decode back into text.")
+});
+const base64DecodeRespondSchema = z.object({
+  result: z.string()
+});
+const urlEncodeRequestSchema = z.object({
+  text: z.string().describe("The text string to URL-encode.")
+});
+const urlEncodeRespondSchema = z.object({
+  result: z.string()
+});
+const urlDecodeRequestSchema = z.object({
+  text: z.string().describe("The URL-encoded string to decode.")
+});
+const urlDecodeRespondSchema = z.object({
+  result: z.string()
+});
+const hashRequestSchema = z.object({
+  text: z.string().describe("The text to hash."),
+  algorithm: z.enum(["md5", "sha1", "sha256"]).default("sha256").describe("Hash algorithm: md5, sha1, or sha256. Default: sha256.")
+});
+const hashRespondSchema = z.object({
+  result: z.string()
+});
+const timeRequestSchema = z.object({
+  format: z.enum(["iso", "timestamp"]).default("iso").describe(
+    "Output format: 'iso' for ISO 8601 string, 'timestamp' for Unix timestamp in seconds."
+  )
+});
+const timeRespondSchema = z.object({
+  result: z.union([z.string(), z.number()])
+});
+const uuidRequestSchema = z.object({});
+const uuidRespondSchema = z.object({
+  result: z.string()
+});
+const shortIdRequestSchema = z.object({
+  length: z.number().int().min(4).max(32).default(8).describe("Length of the short ID (4-32). Default: 8.")
+});
+const shortIdRespondSchema = z.object({
+  result: z.string()
+});
+const randomRequestSchema = z.object({
+  length: z.number().int().min(1).max(256).default(16).describe("Length of the random string (1-256). Default: 16."),
+  charset: z.enum(["alphanumeric", "alpha", "numeric", "hex"]).default("alphanumeric").describe("Character set: alphanumeric, alpha, numeric, or hex. Default: alphanumeric.")
+});
+const randomRespondSchema = z.object({
+  result: z.string()
+});
+const randIntRequestSchema = z.object({
+  min: z.number().int().describe("Minimum value (inclusive)."),
+  max: z.number().int().describe("Maximum value (inclusive).")
+});
+const randIntRespondSchema = z.object({
+  result: z.number().int()
+});
+const choiceRequestSchema = z.object({
+  items: z.array(z.string()).min(1).describe("Array of items to choose from.")
+});
+const choiceRespondSchema = z.object({
+  result: z.string()
+});
+const shuffleRequestSchema = z.object({
+  items: z.array(z.string()).min(1).describe("Array of items to shuffle.")
+});
+const shuffleRespondSchema = z.object({
+  result: z.array(z.string())
+});
+const imageMetadataRequestSchema = z.object({
+  path: z.string().describe("Absolute or project-relative path to the image file.")
+});
+const imageMetadataRespondSchema = z.object({
+  result: z.object({
+    width: z.number().optional(),
+    height: z.number().optional(),
+    format: z.string().optional(),
+    space: z.string().optional(),
+    channels: z.number().optional(),
+    depth: z.string().optional(),
+    density: z.number().optional(),
+    hasAlpha: z.boolean().optional(),
+    size: z.number().optional()
+  })
+});
+const imageThumbnailRequestSchema = z.object({
+  path: z.string().describe("Absolute or project-relative path to the source image."),
+  width: z.number().int().min(1).max(1024).default(200).describe("Thumbnail width in pixels (1-1024). Default: 200."),
+  output: z.string().optional().describe("Output path. If omitted, saves alongside source with '.thumb{width}' suffix.")
+});
+const imageThumbnailRespondSchema = z.object({
+  result: z.object({
+    output: z.string(),
+    metadata: imageMetadataRespondSchema.shape.result
+  })
+});
+const imageResizeRequestSchema = z.object({
+  path: z.string().describe("Absolute or project-relative path to the source image."),
+  width: z.number().int().min(1).optional().describe("Target width in pixels."),
+  height: z.number().int().min(1).optional().describe("Target height in pixels."),
+  fit: z.enum(["cover", "contain", "fill", "inside", "outside"]).default("inside").describe("How to fit the image: cover, contain, fill, inside, outside. Default: inside."),
+  output: z.string().optional().describe("Output path. If omitted, saves alongside source with '.{width}x{height}' suffix.")
+});
+const imageResizeRespondSchema = z.object({
+  result: z.object({
+    output: z.string(),
+    metadata: imageMetadataRespondSchema.shape.result
+  })
+});
+const imageConvertRequestSchema = z.object({
+  path: z.string().describe("Absolute or project-relative path to the source image."),
+  format: z.enum(["jpeg", "png", "webp", "avif", "tiff"]).describe("Target image format."),
+  quality: z.number().int().min(1).max(100).optional().describe("Quality for lossy formats (1-100). Applies to jpeg, webp, avif."),
+  output: z.string().optional().describe("Output path. If omitted, saves alongside source with new extension.")
+});
+const imageConvertRespondSchema = z.object({
+  result: z.object({
+    output: z.string(),
+    metadata: imageMetadataRespondSchema.shape.result
+  })
+});
+function getArg(name) {
+  const idx = process.argv.indexOf(`--${name}`);
+  return idx !== -1 ? process.argv[idx + 1] : void 0;
+}
+const socketPath = getArg("socket-path");
+const projectDir = getArg("project-dir");
+if (!socketPath) {
+  console.error("[mcp-toolbox] Missing required argument: --socket-path");
+  process.exit(1);
+}
+if (!projectDir) {
+  console.error("[mcp-toolbox] Missing required argument: --project-dir");
+  process.exit(1);
+}
+const server = new McpServer({
+  name: "Toolbox",
+  version: "1.0.0",
+  description: "Built-in utility tools: base64, URL encode/decode, hash, time, UUID, random, etc."
+});
+server.registerTool(
+  "base64_encode",
+  {
+    description: "Encode a text string into Base64 format. Supports UTF-8 text.",
+    inputSchema: base64EncodeRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = base64EncodeRespondSchema.parse(
+        await postToSocket("/toolbox/base64-encode", { text: input.text })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "base64_decode",
+  {
+    description: "Decode a Base64-encoded string back into UTF-8 text.",
+    inputSchema: base64DecodeRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = base64DecodeRespondSchema.parse(
+        await postToSocket("/toolbox/base64-decode", { base64: input.base64 })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "url_encode",
+  {
+    description: "URL-encode a text string (percent-encoding).",
+    inputSchema: urlEncodeRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = urlEncodeRespondSchema.parse(
+        await postToSocket("/toolbox/url-encode", { text: input.text })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "url_decode",
+  {
+    description: "Decode a URL-encoded (percent-encoded) string back into text.",
+    inputSchema: urlDecodeRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = urlDecodeRespondSchema.parse(
+        await postToSocket("/toolbox/url-decode", { text: input.text })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "hash",
+  {
+    description: "Compute a hash (MD5, SHA1, or SHA256) of a text string. Returns hex digest.",
+    inputSchema: hashRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = hashRespondSchema.parse(
+        await postToSocket("/toolbox/hash", {
+          text: input.text,
+          algorithm: input.algorithm
+        })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "time",
+  {
+    description: "Get the current time. Returns either an ISO 8601 string or a Unix timestamp in seconds.",
+    inputSchema: timeRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = timeRespondSchema.parse(
+        await postToSocket("/toolbox/time", { format: input.format })
+      );
+      return { content: [{ type: "text", text: String(res.result) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "uuid",
+  {
+    description: "Generate a random UUID v4.",
+    inputSchema: uuidRequestSchema
+  },
+  async () => {
+    try {
+      const res = uuidRespondSchema.parse(await postToSocket("/toolbox/uuid", {}));
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "short_id",
+  {
+    description: "Generate a short random alphanumeric ID.",
+    inputSchema: shortIdRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = shortIdRespondSchema.parse(
+        await postToSocket("/toolbox/short-id", { length: input.length })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "random",
+  {
+    description: "Generate a random string with specified length and character set.",
+    inputSchema: randomRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = randomRespondSchema.parse(
+        await postToSocket("/toolbox/random", {
+          length: input.length,
+          charset: input.charset
+        })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "rand_int",
+  {
+    description: "Generate a random integer between min and max (inclusive).",
+    inputSchema: randIntRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = randIntRespondSchema.parse(
+        await postToSocket("/toolbox/rand-int", { min: input.min, max: input.max })
+      );
+      return { content: [{ type: "text", text: String(res.result) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "choice",
+  {
+    description: "Pick a random item from an array.",
+    inputSchema: choiceRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = choiceRespondSchema.parse(
+        await postToSocket("/toolbox/choice", { items: input.items })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "shuffle",
+  {
+    description: "Shuffle an array randomly (Fisher-Yates).",
+    inputSchema: shuffleRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = shuffleRespondSchema.parse(
+        await postToSocket("/toolbox/shuffle", { items: input.items })
+      );
+      return { content: [{ type: "text", text: JSON.stringify(res.result) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "image_metadata",
+  {
+    description: "Read image metadata (width, height, format, color space, channels, etc.) from a file.",
+    inputSchema: imageMetadataRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = imageMetadataRespondSchema.parse(
+        await postToSocket("/toolbox/image-metadata", { path: input.path })
+      );
+      return { content: [{ type: "text", text: JSON.stringify(res.result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "image_thumbnail",
+  {
+    description: "Generate a thumbnail from an image. Returns the output file path and new image metadata.",
+    inputSchema: imageThumbnailRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = imageThumbnailRespondSchema.parse(
+        await postToSocket("/toolbox/image-thumbnail", {
+          path: input.path,
+          width: input.width,
+          output: input.output
+        })
+      );
+      return { content: [{ type: "text", text: JSON.stringify(res.result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "image_resize",
+  {
+    description: "Resize an image to specified dimensions. Returns the output file path and new image metadata.",
+    inputSchema: imageResizeRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = imageResizeRespondSchema.parse(
+        await postToSocket("/toolbox/image-resize", {
+          path: input.path,
+          width: input.width,
+          height: input.height,
+          fit: input.fit,
+          output: input.output
+        })
+      );
+      return { content: [{ type: "text", text: JSON.stringify(res.result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "image_convert",
+  {
+    description: "Convert an image to a different format (jpeg, png, webp, avif, tiff). Returns the output file path and new image metadata.",
+    inputSchema: imageConvertRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = imageConvertRespondSchema.parse(
+        await postToSocket("/toolbox/image-convert", {
+          path: input.path,
+          format: input.format,
+          quality: input.quality,
+          output: input.output
+        })
+      );
+      return { content: [{ type: "text", text: JSON.stringify(res.result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+function postToSocket(path, body) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const options = {
+      socketPath,
+      path,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(data)
+      }
+    };
+    const req = http.request(options, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        const raw = Buffer.concat(chunks).toString("utf8");
+        try {
+          const parsed = JSON.parse(raw);
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(parsed);
+          } else {
+            reject(new Error(parsed.error || `HTTP ${res.statusCode}: ${raw}`));
+          }
+        } catch {
+          reject(new Error(`Invalid response (${res.statusCode}): ${raw}`));
+        }
+      });
+    });
+    req.on("error", (err) => {
+      reject(new Error(`Socket request failed: ${err.message}`));
+    });
+    req.write(data);
+    req.end();
+  });
+}
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch(console.error);