march-cli 0.1.32 → 0.1.34

package/src/lsp/managed-node-server.mjs

@@ -12,6 +12,7 @@ const MANAGED_PACKAGES = {
   "vscode-json-language-server": ["vscode-langservers-extracted"],
   "vscode-html-language-server": ["vscode-langservers-extracted"],
   "vscode-css-language-server": ["vscode-langservers-extracted"],
+  "sql-language-server": ["sql-language-server"],
   "docker-langserver": ["dockerfile-language-server-nodejs"],
 };
 

package/src/lsp/server-definitions.mjs

@@ -88,6 +88,14 @@ export function createLspServerDefinitions({ resolveTypeScriptProjectRoot, resol
       managedCommand: "vscode-json-language-server",
       args: ["--stdio"],
     },
+    {
+      id: "sql",
+      extensions: [".sql"],
+      rootMarkers: [".sqllsrc.json", ".sqllsrc", "package.json", ".git"],
+      command: ["sql-language-server"],
+      managedCommand: "sql-language-server",
+      args: ["up", "--method", "stdio"],
+    },
     {
       id: "html",
       extensions: [".html", ".htm"],

package/src/main.mjs

@@ -38,7 +38,8 @@ import { installNetworkEnvironment } from "./network/environment.mjs";
 import { runMemoryCommand } from "./memory/command.mjs";
 import { normalizeRemoteMemorySources } from "./memory/remote/config.mjs";
 import { resolveMemoryRoot } from "./memory/root.mjs";
-import { runBrowserCommand } from "./browser/cli/command.mjs";
+import { runConfiguredCliCommand } from "./cli/startup/configured-command.mjs";
+import { maybeRunGatewayDaemonCommand } from "./cli/startup/gateway-daemon-command.mjs";
 import { ensureBrowserDaemon } from "./browser/client/lifecycle.mjs";
 export async function run(argv) {
   const cwd = process.cwd();
@@ -77,14 +78,8 @@ export async function run(argv) {
     args.memoryRoot = resolveMemoryRoot(config.memoryRoot, stateRoot);
     return await runMemoryCommand(args, { homeDir: homedir() });
   }
-  if (args.command?.name === "browser") {
-    try {
-      return await runBrowserCommand(args, { stateRoot });
-    } catch (err) {
-      process.stderr.write(`Error: ${err.message}\n`);
-      return 1;
-    }
-  }
+  const configuredCommand = await runConfiguredCliCommand(args, { config, cwd, stateRoot });
+  if (configuredCommand.handled) return configuredCommand.code;
   if (!existsSync(stateRoot)) mkdirSync(stateRoot, { recursive: true });
   await ensureBrowserDaemon({ stateRoot }).catch(() => {});
   const logger = createLogger({ logDir: join(stateRoot, "logs") });
@@ -243,6 +238,8 @@ export async function run(argv) {
     ui,
   });
   refreshStatusBar();
+  const gatewayDaemonCommand = await maybeRunGatewayDaemonCommand(args, { config, cwd, runner, currentProject, memoryStore, ui, logger });
+  if (gatewayDaemonCommand.handled) return gatewayDaemonCommand.code;
 
   if (args.prompt) {
     turnRunning = true;

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

@@ -0,0 +1,36 @@
+export function isMemoryIdLike(value) {
+  return /^mem_[a-z0-9_-]+$/i.test(String(value ?? ""));
+}
+
+export function isSingleEditAway(left, right) {
+  if (left === right) return true;
+  if (Math.abs(left.length - right.length) > 1) return false;
+  if (left.length === right.length) return hasSingleSubstitution(left, right);
+  return hasSingleInsertionOrDeletion(left, right);
+}
+
+function hasSingleSubstitution(left, right) {
+  let mismatches = 0;
+  for (let i = 0; i < left.length; i += 1) {
+    if (left[i] !== right[i]) mismatches += 1;
+    if (mismatches > 1) return false;
+  }
+  return mismatches === 1;
+}
+
+function hasSingleInsertionOrDeletion(left, right) {
+  const shorter = left.length < right.length ? left : right;
+  const longer = left.length < right.length ? right : left;
+  let edits = 0;
+  for (let i = 0, j = 0; i < shorter.length && j < longer.length; ) {
+    if (shorter[i] === longer[j]) {
+      i += 1;
+      j += 1;
+    } else {
+      edits += 1;
+      j += 1;
+      if (edits > 1) return false;
+    }
+  }
+  return true;
+}

package/src/memory/markdown-store.mjs

@@ -13,6 +13,7 @@ import {
 import { scoreEntry, toHint } from "./markdown/markdown-recall.mjs";
 import { clearMarkdownMemoryIndex, loadMarkdownMemoryIndex, openMarkdownMemoryIndex, queryMarkdownMemoryIndex, replaceMarkdownMemoryIndex } from "./markdown/sqlite-index.mjs";
 import { softDeleteMemoryFile } from "./markdown/markdown-delete.mjs";
+import { isMemoryIdLike, isSingleEditAway } from "./markdown/memory-id.mjs";
 import { openMarkdownRoot, searchMarkdownRoot } from "./search.mjs";
 
 export { formatRecallHints } from "./markdown/markdown-recall.mjs";
@@ -154,10 +155,9 @@ export class MarkdownMemoryStore {
     this.ensureFresh();
     const raw = String(identifier ?? "").trim();
     if (!raw) throw new Error("memory id or path is required");
-    const entry = this.entries.get(raw);
-    const path = entry ? entry.path : this.#resolveMemoryPath(raw);
-    const opened = openMarkdownRoot({ root: this.root, path, ...options });
-    return { ...opened, entry: entry ?? null };
+    const resolved = this.#resolveOpenTarget(raw);
+    const opened = openMarkdownRoot({ root: this.root, path: resolved.path, ...options });
+    return { ...opened, entry: resolved.entry, requestedId: resolved.requestedId };
   }
 
   save({ id = null, name = null, description = null, body = null, tags = null } = {}) {
@@ -261,11 +261,22 @@ export class MarkdownMemoryStore {
     return path;
   }
 
+  #resolveOpenTarget(raw) {
+    const exact = this.entries.get(raw);
+    if (exact) return { path: exact.path, entry: exact, requestedId: null };
+    if (!isMemoryIdLike(raw)) return { path: this.#resolveMemoryPath(raw), entry: null, requestedId: null };
+
+    const candidates = [...this.entries.values()].filter((entry) => isSingleEditAway(raw, entry.id));
+    if (candidates.length === 1) return { path: candidates[0].path, entry: candidates[0], requestedId: raw };
+    if (candidates.length > 1) {
+      throw new Error(`memory id is ambiguous: ${raw}; candidates: ${candidates.map((entry) => entry.id).join(", ")}`);
+    }
+    throw new Error(`memory not found: ${raw}`);
+  }
+
   #activeMemoryPaths() {
     return [...this.entries.values()]
       .filter((entry) => entry.status === "active")
       .map((entry) => entry.path);
   }
-
-
 }

package/src/memory/markdown-tools.mjs

@@ -146,12 +146,13 @@ function formatMemorySearchResults(results, requestedSource) {
 
 function formatLocalOpen(opened) {
   const range = opened.startLine && opened.endLine ? `lines: ${opened.startLine}-${opened.endLine}\n` : "";
-  return `path: ${opened.path}\n${range}Use edit_file with this path for targeted edits.\n\n---\n${opened.content}`;
+  const correction = opened.requestedId && opened.entry?.id ? `matched id: ${opened.entry.id} (requested: ${opened.requestedId})\n` : "";
+  return `path: ${opened.path}\n${correction}${range}Use edit_file with this path for targeted edits.\n\ncontent:\n${opened.content}`;
 }
 
 function formatRemoteOpen(opened) {
   const range = opened.startLine && opened.endLine ? `lines: ${opened.startLine}-${opened.endLine}\n` : "";
-  return `source: ${opened.source}\npath: ${opened.path}\n${range}Remote memory is read-only.\n\n---\n${opened.content}`;
+  return `source: ${opened.source}\npath: ${opened.path}\n${range}Remote memory is read-only.\n\ncontent:\n${opened.content}`;
 }
 
 function formatMemorySearchMiss(query, source) {

package/src/platform/open-file.mjs

@@ -1,9 +1,9 @@
 import { spawn } from "node:child_process";
 
-export function openFileWithDefaultApp(filePath) {
+export function openFileWithDefaultApp(filePath, { spawnFn = spawn } = {}) {
   return new Promise((resolve, reject) => {
-    const { command, args } = openCommand(filePath);
-    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    const { command, args, options } = openCommand(filePath);
+    const child = spawnFn(command, args, { ...options, detached: true, stdio: "ignore" });
     child.once("error", reject);
     child.once("spawn", () => {
       child.unref();
@@ -12,15 +12,14 @@ export function openFileWithDefaultApp(filePath) {
   });
 }
 
-function openCommand(filePath) {
-  if (process.platform === "win32") {
-    return {
-      command: "powershell.exe",
-      args: ["-NoProfile", "-Command", "Start-Process -LiteralPath $args[0]", filePath],
-    };
+export function openCommand(filePath, { platform = process.platform } = {}) {
+  if (platform === "win32") {
+    // cmd.exe start delegates to the user's shell association more reliably than
+    // PowerShell Start-Process for media files on Windows.
+    return { command: "cmd.exe", args: ["/c", "start", "", filePath] };
   }
 
-  if (process.platform === "darwin") {
+  if (platform === "darwin") {
     return { command: "open", args: [filePath] };
   }