march-cli 0.1.31 → 0.1.33

package/src/gateway/workspace-command.mjs

@@ -0,0 +1,40 @@
+export function parseWorkspaceCommand(input) {
+  const trimmed = String(input ?? "").trim();
+  if (trimmed === "/workspace") return { type: "show" };
+  if (trimmed === "/workspaces") return { type: "list" };
+  const match = trimmed.match(/^\/workspace\s+set\s+(\S+)$/);
+  if (match) return { type: "set", alias: match[1] };
+  if (trimmed.startsWith("/workspace ")) return { type: "error", message: "Usage: /workspace, /workspaces, or /workspace set <alias>" };
+  return { type: "none" };
+}
+
+export function handleWorkspaceCommand(command, { session, sessionStore }) {
+  if (command.type === "error") return [`Error: ${command.message}`];
+  if (command.type === "show") return [formatCurrentWorkspace(session)];
+  if (command.type === "list") return formatWorkspaceList(sessionStore.listWorkspaces(), session.workspaceAlias);
+  if (command.type === "set") {
+    try {
+      sessionStore.setWorkspace(session, command.alias);
+      return [`Workspace: ${session.workspaceAlias} (${session.workspaceRoot})`];
+    } catch (err) {
+      return [`Error: ${err.message}`];
+    }
+  }
+  return [];
+}
+
+function formatCurrentWorkspace(session) {
+  if (!session.workspaceAlias || !session.workspaceRoot) return "Workspace: not configured";
+  return `Workspace: ${session.workspaceAlias} (${session.workspaceRoot})`;
+}
+
+function formatWorkspaceList(workspaces, currentAlias) {
+  if (workspaces.length === 0) return ["No gateway workspaces configured."];
+  return [
+    "Gateway workspaces:",
+    ...workspaces.map((workspace) => {
+      const marker = workspace.alias === currentAlias ? "*" : " ";
+      return `${marker} ${workspace.alias}: ${workspace.root}`;
+    }),
+  ];
+}

package/src/image-gen/tool.mjs

@@ -1,14 +1,15 @@
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { basename } from "node:path";
+import { sendBinaryOutput } from "../agent/output/binary-output-sink.mjs";
 import { toolText } from "../agent/tool-result.mjs";
-import { openFileWithDefaultApp } from "../platform/open-file.mjs";
 import { generateImage } from "./provider.mjs";
 
 export function createImageGenTool({
   authStorage,
   projectMarchDir,
   generateImageImpl = generateImage,
-  openFileImpl = openFileWithDefaultApp,
+  sendBinary = sendBinaryOutput,
 }) {
   return defineTool({
     name: "image_generate",
@@ -48,7 +49,7 @@ export function createImageGenTool({
       try {
         const { prompt, quality = "medium", aspectRatio = "1:1", auto_open: autoOpen = true } = params;
         const image = await generateImageImpl({ prompt, quality, aspectRatio, authStorage, projectMarchDir });
-        const openResult = autoOpen ? await openGeneratedImage(image.filePath, openFileImpl) : { opened: false };
+        const outputResult = autoOpen ? await deliverGeneratedImage(image, sendBinary) : { opened: false, delivered: false };
         return toolJson({
           success: true,
           image: image.marker,
@@ -57,8 +58,8 @@ export function createImageGenTool({
           prompt,
           aspectRatio,
           quality,
-          ...openResult,
-        }, { ...image, ...openResult });
+          ...outputResult,
+        }, { ...image, ...outputResult });
       } catch (err) {
         return toolJson({
           success: false,
@@ -70,12 +71,18 @@ export function createImageGenTool({
   });
 }
 
-async function openGeneratedImage(filePath, openFileImpl) {
+async function deliverGeneratedImage(image, sendBinary) {
+  const binary = {
+    type: "image",
+    path: image.filePath,
+    filename: basename(image.filePath),
+    mimeType: image.mimeType,
+  };
   try {
-    await openFileImpl(filePath);
-    return { opened: true };
+    const sink = await sendBinary(binary);
+    return { opened: sink?.opened === true, delivered: true, sink };
   } catch (err) {
-    return { opened: false, openError: err.message };
+    return { opened: false, delivered: false, openError: err.message };
   }
 }
 

package/src/lsp/client.mjs

@@ -47,6 +47,7 @@ const LANGUAGE_IDS = {
   ".sass": "sass",
   ".scss": "scss",
   ".sh": "shellscript",
+  ".sql": "sql",
   ".svelte": "svelte",
   ".tf": "terraform",
   ".tfvars": "terraform-vars",

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/markdown-format.mjs

@@ -55,15 +55,6 @@ export function generateMemoryId() {
   return `mem_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
 }
 
-export function slugify(value) {
-  return String(value ?? "memory")
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9\u4e00-\u9fff]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 80) || "memory";
-}
-
 export function walkMarkdownFiles(root) {
   const out = [];
   if (!existsSync(root)) return out;

package/src/memory/markdown-store.mjs

@@ -8,7 +8,6 @@ import {
   normalizeText,
   parseMemoryMarkdown,
   quoteFtsTerm,
-  slugify,
   walkMarkdownFiles,
 } from "./markdown/markdown-format.mjs";
 import { scoreEntry, toHint } from "./markdown/markdown-recall.mjs";
@@ -176,7 +175,7 @@ export class MarkdownMemoryStore {
     if (!nextDescription) throw new Error("description is required");
     if (!existing && body == null) throw new Error("body is required");
     const nextBody = body ?? (existing ? parseMemoryMarkdown(readFileSync(existing.path, "utf8")).body : "");
-    const nextPath = existing?.path ?? this.#newMemoryPath(now, nextName);
+    const nextPath = existing?.path ?? this.#newMemoryPath(now, nextId);
     mkdirSync(dirname(nextPath), { recursive: true });
     const content = formatMemoryMarkdown({
       frontmatter: {
@@ -248,11 +247,11 @@ export class MarkdownMemoryStore {
     }
   }
 
-  #newMemoryPath(isoDate, name) {
+  #newMemoryPath(isoDate, id) {
     const date = isoDate.slice(0, 10);
     const [year, month, day] = date.split("-");
     const week = `week${Math.ceil(Number(day) / 7)}`;
-    return join(this.root, year, month, week, `${date}-${slugify(name)}.md`);
+    return join(this.root, year, month, week, `${date}-${id}.md`);
   }
 
   #resolveMemoryPath(raw) {

package/src/memory/markdown-tools.mjs

@@ -70,7 +70,7 @@ export function createMarkdownMemoryTools(store, { remoteSources = [] } = {}) {
       name: "memory_save",
       label: "Memory Save",
       description:
-        "Create a Markdown memory or update whole fields on an existing memory. For targeted edits to an existing memory body or frontmatter, use memory_open to get the path, then edit_file. Before creating a new memory, merge related updates into an existing memory when they share the same topic or decision thread. New memories require name, description, body, and at least one tag because recall hints only use tags. When updating by id, omitted fields keep their existing values; passing tags replaces the full tag list.",
+        "Create a Markdown memory or update whole fields on an existing memory. Local memory filenames are id-based storage paths; frontmatter name is the user-visible title. For targeted edits to an existing memory body or frontmatter, use memory_open to get the path, then edit_file. Before creating a new memory, merge related updates into an existing memory when they share the same topic or decision thread. New memories require name, description, body, and at least one tag because recall hints only use tags. When updating by id, omitted fields keep their existing values; passing tags replaces the full tag list.",
       parameters: Type.Object({
         id: Type.Optional(Type.String({ description: "Existing memory id to update. Omit to create a new memory." })),
         name: Type.Optional(Type.String({ description: "Memory name. Required when creating." })),

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] };
   }