march-cli 0.1.23 → 0.1.25

package/src/mcp/index.mjs

@@ -1,48 +1,48 @@
-export { loadMcpConfig, loadMcpConfigHierarchical, detectTransport, validateMcpConfig, serverDisplayName } from "./config.mjs";
-export { McpClientManager } from "./client.mjs";
-export { buildMcpToolName, parseMcpToolName, convertMcpTool, convertAllMcpTools } from "./tools.mjs";
-
-/**
- * Initialize MCP: load config, connect to servers, discover tools.
- * Returns { clientManager, mcpTools, mcpInjections, errors }.
- */
-export async function initializeMcp({ projectDir }) {
-  const { loadMcpConfig } = await import("./config.mjs");
-  const { McpClientManager } = await import("./client.mjs");
-  const { convertAllMcpTools } = await import("./tools.mjs");
-
-  const servers = loadMcpConfig(projectDir);
-  if (servers.size === 0) {
-    return { clientManager: null, mcpTools: [], mcpInjections: [], errors: [] };
-  }
-
-  const clientManager = new McpClientManager();
-  const errors = [];
-  const mcpInjections = [];
-
-  for (const [name, config] of servers) {
-    if (config.enabled === false) continue;
-    try {
-      await clientManager.connect(name, config);
-      await clientManager.discoverTools(name);
-      const injection = buildMcpInstructionsInjection(name, config);
-      if (injection) mcpInjections.push(injection);
-    } catch (err) {
-      errors.push({ server: name, error: err.message });
-    }
-  }
-
-  const mcpTools = convertAllMcpTools(clientManager);
-  return { clientManager, mcpTools, mcpInjections, errors };
-}
-
-export function buildMcpInstructionsInjection(serverName, config) {
-  if (typeof config?.instructions !== "string") return null;
-  const content = config.instructions.trim();
-  if (!content) return null;
-  return {
-    type: "mcp_server",
-    source: serverName,
-    content,
-  };
-}
+export { loadMcpConfig, loadMcpConfigHierarchical, detectTransport, validateMcpConfig, serverDisplayName } from "./config.mjs";
+export { McpClientManager } from "./client.mjs";
+export { buildMcpToolName, parseMcpToolName, convertMcpTool, convertAllMcpTools } from "./tools.mjs";
+
+/**
+ * Initialize MCP: load config, connect to servers, discover tools.
+ * Returns { clientManager, mcpTools, mcpInjections, errors }.
+ */
+export async function initializeMcp({ projectDir }) {
+  const { loadMcpConfig } = await import("./config.mjs");
+  const { McpClientManager } = await import("./client.mjs");
+  const { convertAllMcpTools } = await import("./tools.mjs");
+
+  const servers = loadMcpConfig(projectDir);
+  if (servers.size === 0) {
+    return { clientManager: null, mcpTools: [], mcpInjections: [], errors: [] };
+  }
+
+  const clientManager = new McpClientManager();
+  const errors = [];
+  const mcpInjections = [];
+
+  for (const [name, config] of servers) {
+    if (config.enabled === false) continue;
+    try {
+      await clientManager.connect(name, config);
+      await clientManager.discoverTools(name);
+      const injection = buildMcpInstructionsInjection(name, config);
+      if (injection) mcpInjections.push(injection);
+    } catch (err) {
+      errors.push({ server: name, error: err.message });
+    }
+  }
+
+  const mcpTools = convertAllMcpTools(clientManager);
+  return { clientManager, mcpTools, mcpInjections, errors };
+}
+
+export function buildMcpInstructionsInjection(serverName, config) {
+  if (typeof config?.instructions !== "string") return null;
+  const content = config.instructions.trim();
+  if (!content) return null;
+  return {
+    type: "mcp_server",
+    source: serverName,
+    content,
+  };
+}

package/src/mcp/tools.mjs

@@ -1,98 +1,98 @@
-import { defineTool } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-
-/**
- * Build a tool name from server + tool: mcp__{server}__{tool}
- */
-export function buildMcpToolName(server, tool) {
-  return `mcp__${sanitize(server)}__${sanitize(tool)}`;
-}
-
-/**
- * Parse an MCP tool name back into { server, tool }.
- */
-export function parseMcpToolName(name) {
-  const match = name.match(/^mcp__([^_]+(?:_[^_]+)*?)__([^_]+(?:_.+)?)$/);
-  if (!match) return null;
-  return { server: match[1], tool: match[2] };
-}
-
-function sanitize(s) {
-  return s.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/__+/g, "_");
-}
-
-/**
- * Map JSON Schema type to TypeBox type.
- * Handles the common MCP parameter schemas.
- */
-function schemaToTypeBox(schema) {
-  if (!schema || !schema.properties) return Type.Object({});
-
-  const props = {};
-  const required = new Set(schema.required ?? []);
-
-  for (const [key, prop] of Object.entries(schema.properties)) {
-    let box;
-    switch (prop.type) {
-      case "string":
-        box = Type.String();
-        break;
-      case "number":
-      case "integer":
-        box = Type.Number();
-        break;
-      case "boolean":
-        box = Type.Boolean();
-        break;
-      case "array":
-        box = Type.Array(
-          prop.items ? schemaToTypeBox(prop.items) : Type.Any(),
-        );
-        break;
-      case "object":
-        box = schemaToTypeBox(prop);
-        break;
-      default:
-        box = Type.Any();
-    }
-    if (prop.description) box = box({ description: prop.description });
-    if (!required.has(key)) box = Type.Optional(box);
-    props[key] = box;
-  }
-
-  return Type.Object(props);
-}
-
-/**
- * Convert an MCP tool definition to a March-compatible tool.
- */
-export function convertMcpTool(serverName, mcpTool, clientManager) {
-  const fullName = buildMcpToolName(serverName, mcpTool.name);
-  const description = mcpTool.description ?? `MCP tool: ${serverName}/${mcpTool.name}`;
-
-  return defineTool({
-    name: fullName,
-    label: `MCP:${serverName}/${mcpTool.name}`,
-    description: `[MCP ${serverName}] ${description}`,
-    parameters: schemaToTypeBox(mcpTool.inputSchema),
-    execute: async (_toolCallId, params) => {
-      const result = await clientManager.callTool(serverName, mcpTool.name, params);
-      return {
-        content: [{ type: "text", text: result.content }],
-        details: result.details,
-      };
-    },
-  });
-}
-
-/**
- * Batch-convert all tools from all connected servers.
- */
-export function convertAllMcpTools(clientManager) {
-  const tools = [];
-  const allTools = clientManager.getAllTools();
-  for (const { server, tool } of allTools) {
-    tools.push(convertMcpTool(server, tool, clientManager));
-  }
-  return tools;
-}
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+/**
+ * Build a tool name from server + tool: mcp__{server}__{tool}
+ */
+export function buildMcpToolName(server, tool) {
+  return `mcp__${sanitize(server)}__${sanitize(tool)}`;
+}
+
+/**
+ * Parse an MCP tool name back into { server, tool }.
+ */
+export function parseMcpToolName(name) {
+  const match = name.match(/^mcp__([^_]+(?:_[^_]+)*?)__([^_]+(?:_.+)?)$/);
+  if (!match) return null;
+  return { server: match[1], tool: match[2] };
+}
+
+function sanitize(s) {
+  return s.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/__+/g, "_");
+}
+
+/**
+ * Map JSON Schema type to TypeBox type.
+ * Handles the common MCP parameter schemas.
+ */
+function schemaToTypeBox(schema) {
+  if (!schema || !schema.properties) return Type.Object({});
+
+  const props = {};
+  const required = new Set(schema.required ?? []);
+
+  for (const [key, prop] of Object.entries(schema.properties)) {
+    let box;
+    switch (prop.type) {
+      case "string":
+        box = Type.String();
+        break;
+      case "number":
+      case "integer":
+        box = Type.Number();
+        break;
+      case "boolean":
+        box = Type.Boolean();
+        break;
+      case "array":
+        box = Type.Array(
+          prop.items ? schemaToTypeBox(prop.items) : Type.Any(),
+        );
+        break;
+      case "object":
+        box = schemaToTypeBox(prop);
+        break;
+      default:
+        box = Type.Any();
+    }
+    if (prop.description) box = box({ description: prop.description });
+    if (!required.has(key)) box = Type.Optional(box);
+    props[key] = box;
+  }
+
+  return Type.Object(props);
+}
+
+/**
+ * Convert an MCP tool definition to a March-compatible tool.
+ */
+export function convertMcpTool(serverName, mcpTool, clientManager) {
+  const fullName = buildMcpToolName(serverName, mcpTool.name);
+  const description = mcpTool.description ?? `MCP tool: ${serverName}/${mcpTool.name}`;
+
+  return defineTool({
+    name: fullName,
+    label: `MCP:${serverName}/${mcpTool.name}`,
+    description: `[MCP ${serverName}] ${description}`,
+    parameters: schemaToTypeBox(mcpTool.inputSchema),
+    execute: async (_toolCallId, params) => {
+      const result = await clientManager.callTool(serverName, mcpTool.name, params);
+      return {
+        content: [{ type: "text", text: result.content }],
+        details: result.details,
+      };
+    },
+  });
+}
+
+/**
+ * Batch-convert all tools from all connected servers.
+ */
+export function convertAllMcpTools(clientManager) {
+  const tools = [];
+  const allTools = clientManager.getAllTools();
+  for (const { server, tool } of allTools) {
+    tools.push(convertMcpTool(server, tool, clientManager));
+  }
+  return tools;
+}

package/src/memory/command.mjs

@@ -0,0 +1,120 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { createRemoteMemoryServer, createMemoryServerToken } from "./remote/server.mjs";
+import { defaultRemoteMemoryName, normalizeSourceName, parseRemoteMemoryUrl } from "./remote/config.mjs";
+import { upsertRemoteMemorySource, removeRemoteMemorySource, readConfigJson, globalConfigJsonPath } from "../config/config-json.mjs";
+import { RemoteMemoryClient } from "./remote/client.mjs";
+
+export async function runMemoryCommand(args, { homeDir = homedir(), stdout = process.stdout, stderr = process.stderr } = {}) {
+  const subcommand = args.command?.args?.[0] ?? "list";
+  const rest = args.command?.args?.slice(1) ?? [];
+  try {
+    if (subcommand === "serve") return await runServeCommand(args, rest, { homeDir, stdout });
+    if (subcommand === "add") return await runAddCommand(args, rest, { homeDir, stdout });
+    if (subcommand === "list") return runListCommand({ homeDir, stdout });
+    if (subcommand === "remove") return runRemoveCommand(rest, { homeDir, stdout });
+    stderr.write(memoryUsage());
+    return 1;
+  } catch (err) {
+    stderr.write(`Error: ${err.message}\n`);
+    return 1;
+  }
+}
+
+async function runServeCommand(args, rest, { homeDir, stdout }) {
+  const folder = resolve(rest[0] ?? args.memoryRoot ?? join(homeDir, ".march", "March Memories"));
+  if (!existsSync(folder)) throw new Error(`folder does not exist: ${folder}`);
+  const name = normalizeSourceName(args.name) || normalizeSourceName(basename(folder)) || "remote-memory";
+  const host = args.host ?? "127.0.0.1";
+  const port = Number(args.port ?? 4317);
+  const token = args.token || createMemoryServerToken();
+
+  if (!args.foreground) {
+    const childArgs = [process.argv[1], "memory", "serve", folder, "--foreground", "--host", host, "--port", String(port), "--name", name, "--token", token];
+    const child = spawn(process.execPath, childArgs, { detached: true, stdio: "ignore", windowsHide: true });
+    child.unref();
+    const url = `http://${host}:${port}`;
+    writeServerState({ homeDir, pid: child.pid, folder, name, url, token });
+    stdout.write(formatServeStarted({ name, url, token, pid: child.pid }));
+    return 0;
+  }
+
+  const remote = createRemoteMemoryServer({ root: folder, name, token });
+  await new Promise((resolveListen, reject) => {
+    remote.server.once("error", reject);
+    remote.server.listen(port, host, resolveListen);
+  });
+  const address = remote.server.address();
+  const actualHost = host === "0.0.0.0" ? host : address.address;
+  const url = `http://${actualHost}:${address.port}`;
+  writeServerState({ homeDir, pid: process.pid, folder, name, url, token });
+  stdout.write(formatServeStarted({ name, url, token, pid: process.pid }));
+  await new Promise(() => {});
+  return 0;
+}
+
+async function runAddCommand(args, rest, { homeDir, stdout }) {
+  const rawUrl = rest[0];
+  if (!rawUrl) throw new Error("Usage: march memory add <url> [--name <name>]");
+  const parsed = parseRemoteMemoryUrl(rawUrl, { token: args.token });
+  if (!parsed.url) throw new Error(`invalid remote memory URL: ${rawUrl}`);
+  let name = normalizeSourceName(args.name);
+  if (!name) {
+    name = await resolveRemoteName(parsed) || defaultRemoteMemoryName(parsed.url);
+  }
+  upsertRemoteMemorySource({ path: globalConfigJsonPath(homeDir), name, url: parsed.url, token: parsed.token });
+  stdout.write(`Added remote memory: ${name}\nurl: ${parsed.url}\n`);
+  return 0;
+}
+
+function runListCommand({ homeDir, stdout }) {
+  const config = readConfigJson(globalConfigJsonPath(homeDir));
+  const sources = Array.isArray(config.remoteMemories) ? config.remoteMemories : [];
+  if (sources.length === 0) {
+    stdout.write("No remote memories configured.\n");
+    return 0;
+  }
+  stdout.write(sources.map((source) => `${source.name}\t${source.url}`).join("\n") + "\n");
+  return 0;
+}
+
+function runRemoveCommand(rest, { homeDir, stdout }) {
+  const name = normalizeSourceName(rest[0]);
+  if (!name) throw new Error("Usage: march memory remove <name>");
+  const removed = removeRemoteMemorySource({ path: globalConfigJsonPath(homeDir), name });
+  stdout.write(removed ? `Removed remote memory: ${name}\n` : `Remote memory not found: ${name}\n`);
+  return removed ? 0 : 1;
+}
+
+async function resolveRemoteName({ url, token }) {
+  try {
+    const metadata = await new RemoteMemoryClient({ name: "remote", url, token }).metadata();
+    return normalizeSourceName(metadata.name);
+  } catch {
+    return null;
+  }
+}
+
+function writeServerState({ homeDir, ...state }) {
+  const dir = join(homeDir, ".march");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "memory-server.json"), `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+
+function formatServeStarted({ name, url, token, pid }) {
+  const addUrl = `${url}?token=${encodeURIComponent(token)}`;
+  return [
+    "Remote memory server started",
+    `name: ${name}`,
+    `url:  ${url}`,
+    `pid:  ${pid}`,
+    `add:  march memory add ${addUrl} --name ${name}`,
+    "",
+  ].join("\n");
+}
+
+function memoryUsage() {
+  return `Usage:\n  march memory serve [folder] [--host <host>] [--port <port>] [--name <name>]\n  march memory add <url> [--name <name>]\n  march memory list\n  march memory remove <name>\n`;
+}

package/src/memory/markdown/markdown-delete.mjs

@@ -1,23 +1,23 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { formatMemoryMarkdown, normalizeTags, parseMemoryMarkdown } from "./markdown-format.mjs";
-
-export function softDeleteMemoryFile({ path, entry = null, now = () => new Date() } = {}) {
-  if (!existsSync(path)) throw new Error(`memory not found: ${path}`);
-  const parsed = parseMemoryMarkdown(readFileSync(path, "utf8"));
-  const id = String(parsed.frontmatter.id ?? entry?.id ?? "");
-  if (!id) throw new Error(`memory file is missing id: ${path}`);
-  if (String(parsed.frontmatter.status ?? "active") === "deleted") {
-    return { id, path, status: "deleted", alreadyDeleted: true };
-  }
-  writeFileSync(path, formatMemoryMarkdown({
-    frontmatter: {
-      ...parsed.frontmatter,
-      id,
-      tags: normalizeTags(parsed.frontmatter.tags ?? entry?.tags ?? []),
-      status: "deleted",
-      updated_at: now().toISOString(),
-    },
-    body: parsed.body,
-  }), "utf8");
-  return { id, path, status: "deleted", alreadyDeleted: false };
-}
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { formatMemoryMarkdown, normalizeTags, parseMemoryMarkdown } from "./markdown-format.mjs";
+
+export function softDeleteMemoryFile({ path, entry = null, now = () => new Date() } = {}) {
+  if (!existsSync(path)) throw new Error(`memory not found: ${path}`);
+  const parsed = parseMemoryMarkdown(readFileSync(path, "utf8"));
+  const id = String(parsed.frontmatter.id ?? entry?.id ?? "");
+  if (!id) throw new Error(`memory file is missing id: ${path}`);
+  if (String(parsed.frontmatter.status ?? "active") === "deleted") {
+    return { id, path, status: "deleted", alreadyDeleted: true };
+  }
+  writeFileSync(path, formatMemoryMarkdown({
+    frontmatter: {
+      ...parsed.frontmatter,
+      id,
+      tags: normalizeTags(parsed.frontmatter.tags ?? entry?.tags ?? []),
+      status: "deleted",
+      updated_at: now().toISOString(),
+    },
+    body: parsed.body,
+  }), "utf8");
+  return { id, path, status: "deleted", alreadyDeleted: false };
+}