march-cli 0.1.0

package/src/memory/snapshot.mjs

@@ -0,0 +1,86 @@
+export class ChangesetStore {
+  constructor(db) {
+    this.db = db;
+    this.#ensureSchema();
+  }
+
+  #ensureSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS changesets (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        memory_id INTEGER NOT NULL REFERENCES memories(id),
+        node_uuid TEXT NOT NULL REFERENCES nodes(uuid),
+        before_content TEXT,
+        after_content TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_changesets_node ON changesets(node_uuid);
+      CREATE INDEX IF NOT EXISTS idx_changesets_memory ON changesets(memory_id);
+    `);
+  }
+
+  /**
+   * Record a before/after snapshot for a memory update.
+   * @param {number} memoryId - the NEW memory id
+   * @param {string} nodeUuid
+   * @param {string|null} beforeContent - previous content (null if creation)
+   * @param {string} afterContent - new content
+   */
+  record({ memoryId, nodeUuid, beforeContent, afterContent }) {
+    const result = this.db.prepare(
+      "INSERT INTO changesets (memory_id, node_uuid, before_content, after_content) VALUES (?, ?, ?, ?)",
+    ).run(memoryId, nodeUuid, beforeContent ?? null, afterContent);
+    return { id: Number(result.lastInsertRowid), memory_id: memoryId, node_uuid: nodeUuid };
+  }
+
+  /**
+   * Get all changesets for a node, most recent first.
+   */
+  getHistory(nodeUuid, limit = 50) {
+    return this.db.prepare(
+      "SELECT * FROM changesets WHERE node_uuid = ? ORDER BY id DESC LIMIT ?",
+    ).all(nodeUuid, limit);
+  }
+
+  /**
+   * Get the most recent changesets across all nodes.
+   */
+  getRecent(limit = 30) {
+    return this.db.prepare(
+      "SELECT * FROM changesets ORDER BY id DESC LIMIT ?",
+    ).all(limit);
+  }
+
+  /**
+   * Get a specific changeset by id.
+   */
+  getById(id) {
+    return this.db.prepare("SELECT * FROM changesets WHERE id = ?").get(id);
+  }
+
+  /**
+   * Get the diff summary for a changeset — useful for display.
+   */
+  diff(changeset) {
+    const before = changeset.before_content ?? "";
+    const after = changeset.after_content ?? "";
+    if (!before) return { type: "create", linesAdded: after.split("\n").length };
+    if (!after) return { type: "delete", linesRemoved: before.split("\n").length };
+
+    const beforeLines = before.split("\n");
+    const afterLines = after.split("\n");
+    const added = afterLines.filter((l) => !before.includes(l)).length;
+    const removed = beforeLines.filter((l) => !after.includes(l)).length;
+    return { type: "update", linesAdded: Math.max(0, afterLines.length - beforeLines.length), linesRemoved: Math.max(0, beforeLines.length - afterLines.length), changedLines: added + removed };
+  }
+
+  /**
+   * Delete changesets older than the given number of days.
+   */
+  pruneOlderThan(days) {
+    const result = this.db.prepare(
+      "DELETE FROM changesets WHERE created_at < datetime('now', ?)",
+    ).run(`-${days} days`);
+    return result.changes;
+  }
+}

package/src/memory/system-views.mjs

@@ -0,0 +1,120 @@
+import { ROOT_NODE_UUID } from "./database.mjs";
+
+export class SystemViews {
+  constructor(db, graph, glossaryService, namespace = "") {
+    this.db = db;
+    this.graph = graph;
+    this.glossarySvc = glossaryService;
+    this.namespace = namespace;
+  }
+
+  /**
+   * system://boot — children of the root node (project boot entries).
+   */
+  boot() {
+    const children = this.graph.getChildren(ROOT_NODE_UUID, null, null, this.namespace);
+    return children.map(c => ({
+      name: c.name,
+      node_uuid: c.node_uuid,
+      priority: c.priority,
+      disclosure: c.disclosure,
+      content: c.content_snippet ?? null,
+    }));
+  }
+
+  /**
+   * system://index — all paths with their node UUIDs, grouped by domain.
+   */
+  index() {
+    const rows = this.db.prepare(
+      "SELECT domain, path, node_uuid, namespace FROM paths WHERE namespace = ? OR namespace = 'global' ORDER BY domain, path",
+    ).all(this.namespace);
+    const domains = {};
+    for (const row of rows) {
+      const d = row.domain || "core";
+      if (!domains[d]) domains[d] = [];
+      domains[d].push({ path: row.path, node_uuid: row.node_uuid, namespace: row.namespace });
+    }
+    return domains;
+  }
+
+  /**
+   * system://recent — most recently updated memories.
+   */
+  recent(limit = 20) {
+    return this.graph.getRecentMemories(limit, this.namespace);
+  }
+
+  /**
+   * system://glossary — all glossary keywords with linked nodes.
+   */
+  glossaryList() {
+    return this.glossarySvc.getAllKeywords();
+  }
+
+  /**
+   * system://diagnostic — health and stats overview.
+   */
+  diagnostic() {
+    const ns = this.namespace;
+    const nodeCount = this.db.prepare("SELECT COUNT(*) AS cnt FROM nodes").get().cnt;
+    const memoryCount = this.db.prepare("SELECT COUNT(DISTINCT m.id) AS cnt FROM memories m JOIN paths p ON p.node_uuid = m.node_uuid WHERE m.deprecated = 0 AND (p.namespace = ? OR p.namespace = 'global')").get(ns).cnt;
+    const deprecatedCount = this.db.prepare("SELECT COUNT(*) AS cnt FROM memories WHERE deprecated = 1").get().cnt;
+    const edgeCount = this.db.prepare("SELECT COUNT(DISTINCT e.id) AS cnt FROM edges e JOIN paths p ON p.edge_id = e.id WHERE p.namespace = ? OR p.namespace = 'global'").get(ns).cnt;
+    const pathCount = this.db.prepare("SELECT COUNT(*) AS cnt FROM paths WHERE namespace = ? OR namespace = 'global'").get(ns).cnt;
+    const keywordCount = this.db.prepare("SELECT COUNT(*) AS cnt FROM glossary_keywords WHERE namespace = ? OR namespace = 'global'").get(ns).cnt;
+    const ftsCount = this.#ftsCount();
+    const changesetCount = this.#changesetCount();
+
+    // Stale nodes: no access in 30 days
+    const cutoff = new Date(Date.now() - 30 * 86400000).toISOString();
+    const staleNodes = this.db.prepare(
+      "SELECT COUNT(*) AS cnt FROM nodes WHERE last_accessed_at IS NOT NULL AND last_accessed_at < ?",
+    ).get(cutoff).cnt;
+
+    // Orphan nodes: nodes with no paths pointing to them
+    const orphanNodes = this.db.prepare(`
+      SELECT COUNT(*) AS cnt FROM nodes n
+      WHERE n.uuid != ?
+      AND NOT EXISTS (SELECT 1 FROM paths WHERE node_uuid = n.uuid)
+      AND NOT EXISTS (SELECT 1 FROM edges WHERE child_uuid = n.uuid)
+    `).get(ROOT_NODE_UUID).cnt;
+
+    // Version chain depth stats
+    const versionStats = this.db.prepare(`
+      SELECT MAX(vc) AS max_depth, AVG(vc) AS avg_depth
+      FROM (SELECT COUNT(*) AS vc FROM memories GROUP BY node_uuid)
+    `).get();
+
+    return {
+      counts: {
+        nodes: nodeCount,
+        memories: memoryCount,
+        deprecated_memories: deprecatedCount,
+        edges: edgeCount,
+        paths: pathCount,
+        keywords: keywordCount,
+        fts_documents: ftsCount,
+        changesets: changesetCount,
+      },
+      health: {
+        stale_nodes: staleNodes,
+        orphan_nodes: orphanNodes,
+        max_version_depth: versionStats.max_depth ?? 0,
+        avg_version_depth: Math.round((versionStats.avg_depth ?? 0) * 100) / 100,
+      },
+    };
+  }
+
+  #ftsCount() {
+    try {
+      return this.db.prepare("SELECT COUNT(*) AS cnt FROM search_fts").get().cnt;
+    } catch { return 0; }
+  }
+
+  #changesetCount() {
+    try {
+      return this.db.prepare("SELECT COUNT(*) AS cnt FROM changesets").get().cnt;
+    } catch { return 0; }
+  }
+}

package/src/memory/tools.mjs

@@ -0,0 +1,282 @@
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { toolText } from "../agent/tool-result.mjs";
+import { SystemViews } from "./system-views.mjs";
+
+export function createMemoryTools(graph, glossary, searchIndexer = null, systemViews = null, namespace = "") {
+  const ns = namespace;
+  return [
+    defineTool({
+      name: "read_memory",
+      label: "Read Memory",
+      description: "Read a memory entry from the March memory graph by its path (e.g. 'core://notes/architecture'). Supports system:// views: system://boot, system://index, system://recent, system://glossary, system://diagnostic.",
+      parameters: Type.Object({
+        path: Type.String({ description: "Memory path like 'notes/architecture' (core domain), full URI, or system:// view" }),
+        domain: Type.Optional(Type.String({ description: "Domain. Default: 'core'" })),
+      }),
+      execute: async (_toolCallId, params) => {
+        let domain = params.domain ?? "core";
+        let path = params.path;
+        // Parse domain://path format
+        const uriMatch = path.match(/^([a-z][a-z0-9+.-]*):\/\/(.+)/);
+        if (uriMatch) {
+          domain = uriMatch[1];
+          path = uriMatch[2];
+        }
+
+        // system:// views
+        if (domain === "system" && systemViews) {
+          return handleSystemView(path, systemViews);
+        }
+
+        // Try project namespace first, then global
+        let memory = graph.getMemoryByPath(path, domain, ns);
+        if (!memory) {
+          memory = graph.getMemoryByPath(path, domain, "global");
+        }
+        if (!memory) {
+          return toolText(`No memory found at ${domain}://${path}`);
+        }
+        return toolText(
+          `--- ${domain}://${path} ---\n${memory.content}\n\npriority: ${memory.priority} | aliases: ${memory.alias_count} | deprecated: ${memory.deprecated}`,
+          { memory },
+        );
+      },
+    }),
+
+    defineTool({
+      name: "create_memory",
+      label: "Create Memory",
+      description: "Create a new memory entry under a parent path. Stores content in the graph with a URI path.",
+      parameters: Type.Object({
+        parent_path: Type.String({ description: "Parent path (empty string for root)" }),
+        content: Type.String({ description: "Memory content to store" }),
+        title: Type.Optional(Type.String({ description: "Path title. Auto-numbered if omitted." })),
+        priority: Type.Optional(Type.Number({ description: "Priority (lower = more important). Default: 0" })),
+        domain: Type.Optional(Type.String({ description: "Domain. Default: 'core'" })),
+        scope: Type.Optional(Type.String({ description: "'project' (default) or 'global'" })),
+      }),
+      execute: async (_toolCallId, params) => {
+        const scope = params.scope === "global" ? "global" : ns;
+        const result = graph.createMemory(
+          params.parent_path ?? "",
+          params.content,
+          params.priority ?? 0,
+          { title: params.title ?? null, domain: params.domain ?? "core", namespace: scope },
+        );
+        return toolText(
+          `Created ${result.uri}\nnode: ${result.node_uuid}\npriority: ${result.priority}`,
+          { memory: result },
+        );
+      },
+    }),
+
+    defineTool({
+      name: "update_memory",
+      label: "Update Memory",
+      description: "Update a memory's content or metadata. Content changes create a new version (old version preserved for rollback).",
+      parameters: Type.Object({
+        path: Type.String({ description: "Memory path to update" }),
+        content: Type.Optional(Type.String({ description: "New content" })),
+        priority: Type.Optional(Type.Number({ description: "New priority" })),
+        disclosure: Type.Optional(Type.String({ description: "Disclosure hint for context injection" })),
+        domain: Type.Optional(Type.String({ description: "Domain. Default: 'core'" })),
+        scope: Type.Optional(Type.String({ description: "'project' (default) or 'global'" })),
+      }),
+      execute: async (_toolCallId, params) => {
+        if (params.scope && params.scope !== "project" && params.scope !== "global") {
+          return toolText("Error: scope must be 'project' or 'global'.", { error: true });
+        }
+        const scope = params.scope === "global" ? "global" : ns;
+        const result = graph.updateMemory(params.path, {
+          content: params.content ?? null,
+          priority: params.priority ?? null,
+          disclosure: params.disclosure ?? null,
+          domain: params.domain ?? "core",
+          namespace: scope,
+        });
+        return toolText(
+          `Updated ${result.uri}\nold_memory: ${result.old_memory_id} → new_memory: ${result.new_memory_id}`,
+          { result },
+        );
+      },
+    }),
+
+    defineTool({
+      name: "delete_memory",
+      label: "Delete Memory",
+      description: "Remove a memory path. Refuses if children would become unreachable (provide alternative paths first).",
+      parameters: Type.Object({
+        path: Type.String({ description: "Memory path to delete" }),
+        domain: Type.Optional(Type.String({ description: "Domain. Default: 'core'" })),
+      }),
+      execute: async (_toolCallId, params) => {
+        try {
+          const result = graph.removePath(params.path, params.domain ?? "core", ns);
+          return toolText(`Deleted: ${result.deleted}`, { result });
+        } catch (err) {
+          return toolText(`Error: ${err.message}`, { error: true });
+        }
+      },
+    }),
+
+    defineTool({
+      name: "add_alias",
+      label: "Add Alias",
+      description: "Create an alternative path (alias) pointing to the same memory. Useful for cross-referencing.",
+      parameters: Type.Object({
+        new_path: Type.String({ description: "New alias path" }),
+        target_path: Type.String({ description: "Existing target path" }),
+        domain: Type.Optional(Type.String({ description: "Domain for both paths. Default: 'core'" })),
+      }),
+      execute: async (_toolCallId, params) => {
+        try {
+          const domain = params.domain ?? "core";
+          const result = graph.addPath(params.new_path, params.target_path, { newDomain: domain, targetDomain: domain, namespace: ns });
+          return toolText(`Alias created: ${result.new_uri} → ${result.target_uri}`, { result });
+        } catch (err) {
+          return toolText(`Error: ${err.message}`, { error: true });
+        }
+      },
+    }),
+
+    defineTool({
+      name: "manage_triggers",
+      label: "Manage Triggers",
+      description: "Add or remove glossary keyword triggers. When a keyword appears in user messages, the linked memory is auto-disclosed in context.",
+      parameters: Type.Object({
+        action: Type.String({ description: "'add' or 'remove'" }),
+        keyword: Type.Optional(Type.String({ description: "Keyword/phrase to trigger on. Required for 'add'." })),
+        keyword_id: Type.Optional(Type.Number({ description: "Keyword ID to remove. Required for 'remove'." })),
+        path: Type.Optional(Type.String({ description: "Memory path to link keyword to. Required for 'add'." })),
+        domain: Type.Optional(Type.String({ description: "Domain. Default: 'core'" })),
+      }),
+      execute: async (_toolCallId, params) => {
+        if (params.action === "add") {
+          if (!params.keyword || !params.path) {
+            return toolText("Error: keyword and path are required for 'add' action.", { error: true });
+          }
+          const domain = params.domain ?? "core";
+          const memory = graph.getMemoryByPath(params.path, domain);
+          if (!memory) {
+            return toolText(`Error: path not found: ${domain}://${params.path}`, { error: true });
+          }
+          glossary.addKeyword(params.keyword, memory.node_uuid, ns);
+          return toolText(`Keyword '${params.keyword}' bound to ${domain}://${params.path}`);
+        }
+
+        if (params.action === "remove") {
+          if (!params.keyword_id) {
+            return toolText("Error: keyword_id is required for 'remove' action.", { error: true });
+          }
+          glossary.removeKeyword(params.keyword_id);
+          return toolText(`Keyword ${params.keyword_id} removed.`);
+        }
+
+        return toolText("Error: action must be 'add' or 'remove'.", { error: true });
+      },
+    }),
+
+    defineTool({
+      name: "search_memory",
+      label: "Search Memory",
+      description: "Full-text search across all memory content. Returns ranked results with snippets.",
+      parameters: Type.Object({
+        query: Type.String({ description: "Search query" }),
+        limit: Type.Optional(Type.Number({ description: "Max results. Default: 10" })),
+      }),
+      execute: async (_toolCallId, params) => {
+        const limit = params.limit ?? 10;
+
+        if (searchIndexer) {
+          // Search in project namespace; FTS5 supports OR across namespaces
+          const results = searchIndexer.search(params.query, { limit });
+          if (results.length === 0) {
+            return toolText(`No memories matching "${params.query}".`);
+          }
+          const lines = results.map((r) => {
+            const paths = graph.getPathsForNode(r.node_uuid, r.namespace);
+            const uri = paths.length > 0
+              ? `${paths[0].domain}://${paths[0].path}`
+              : `node:${r.node_uuid}`;
+            return `--- ${uri} (score: ${r.score?.toFixed(1) ?? "?"}) ---\n${r.snippet ?? r.content?.slice(0, 200)}`;
+          });
+          const limitHint = results.length >= limit ? `\n\nShowing first ${limit} matches. Increase limit if you need more.` : "";
+          return toolText(`${results.length} results for "${params.query}":\n\n${lines.join("\n\n")}${limitHint}`, { results });
+        }
+
+        // Fallback: return recent memories from both namespaces
+        const recent = graph.getRecentMemories(limit, ns);
+        const globalRecent = graph.getRecentMemories(Math.max(0, limit - recent.length), "global");
+        const all = [...recent, ...globalRecent].sort((a, b) => (b.created_at ?? "").localeCompare(a.created_at ?? "")).slice(0, limit);
+        if (all.length === 0) {
+          return toolText("No memories found. The memory graph is empty.");
+        }
+        const lines = all.map((m) => `${m.uri} | priority: ${m.priority} | ${m.created_at}`);
+        const limitHint = all.length >= limit ? `\n\nShowing first ${limit} memories. Increase limit if you need more.` : "";
+        return toolText(`${all.length} recent memories:\n\n${lines.join("\n")}${limitHint}`, { memories: all });
+      },
+    }),
+  ];
+}
+
+function handleSystemView(path, views) {
+  try {
+    switch (path) {
+      case "boot": {
+        const items = views.boot();
+        if (items.length === 0) return toolText("system://boot\n(no boot entries)");
+        const lines = items.map(i =>
+          `- ${i.name} (${i.node_uuid.slice(0, 8)}...)  priority:${i.priority}  disclosure:${i.disclosure ?? "-"}\n  ${i.content ?? "(no content)"}`
+        );
+        return toolText(`system://boot — ${items.length} entries\n\n${lines.join("\n\n")}`);
+      }
+      case "index": {
+        const domains = views.index();
+        const total = Object.values(domains).flat().length;
+        const lines = [`system://index — ${total} paths across ${Object.keys(domains).length} domains\n`];
+        for (const [domain, paths] of Object.entries(domains)) {
+          lines.push(`## ${domain}:// (${paths.length} paths)`);
+          for (const p of paths.slice(0, 50)) {
+            lines.push(`  - ${p.path}  →  ${p.node_uuid.slice(0, 8)}...`);
+          }
+          if (paths.length > 50) lines.push(`  ... and ${paths.length - 50} more`);
+        }
+        return toolText(lines.join("\n"));
+      }
+      case "recent": {
+        const items = views.recent(20);
+        if (items.length === 0) return toolText("system://recent\n(no recent memories)");
+        const lines = items.map(m =>
+          `${m.uri}  priority:${m.priority}  ${m.created_at}`
+        );
+        return toolText(`system://recent — ${items.length} entries\n\n${lines.join("\n")}`);
+      }
+      case "glossary": {
+        const items = views.glossaryList();
+        if (items.length === 0) return toolText("system://glossary\n(no keywords)");
+        const lines = items.map(k =>
+          `- [${k.id}] "${k.keyword}" → ${k.node_uuid.slice(0, 8)}...`
+        );
+        return toolText(`system://glossary — ${items.length} keywords\n\n${lines.join("\n")}`);
+      }
+      case "diagnostic": {
+        const d = views.diagnostic();
+        return toolText(
+          `system://diagnostic\n\n` +
+          `## Counts\n` +
+          `  nodes: ${d.counts.nodes}  memories: ${d.counts.memories}  deprecated: ${d.counts.deprecated_memories}\n` +
+          `  edges: ${d.counts.edges}  paths: ${d.counts.paths}  keywords: ${d.counts.keywords}\n` +
+          `  fts_docs: ${d.counts.fts_documents}  changesets: ${d.counts.changesets}\n\n` +
+          `## Health\n` +
+          `  stale_nodes: ${d.health.stale_nodes}  orphan_nodes: ${d.health.orphan_nodes}\n` +
+          `  version_depth: avg ${d.health.avg_version_depth}, max ${d.health.max_version_depth}`
+        );
+      }
+      default:
+        return toolText(`Unknown system:// view: "${path}". Available: boot, index, recent, glossary, diagnostic`);
+    }
+  } catch (err) {
+    return toolText(`Error reading system://${path}: ${err.message}`, { error: true });
+  }
+}

package/src/notification/desktop-notifier.mjs

@@ -0,0 +1,85 @@
+import { spawn } from "node:child_process";
+
+const DEFAULT_BALLOON_TIMEOUT_MS = 5000;
+
+export function createDesktopTurnNotifier({
+  enabled = true,
+  platform = process.platform,
+  spawnProcess = spawn,
+} = {}) {
+  return {
+    async notifyTurnEnd(event) {
+      if (!enabled) return { ok: false, reason: "disabled" };
+      return sendDesktopNotification({
+        platform,
+        spawnProcess,
+        title: event?.title ?? defaultTurnTitle(event?.status),
+        message: event?.message ?? defaultTurnMessage(event),
+      });
+    },
+  };
+}
+
+export async function sendDesktopNotification({ platform = process.platform, spawnProcess = spawn, title, message }) {
+  if (platform !== "win32") return { ok: false, reason: "unsupported-platform" };
+
+  const safeTitle = normalizeNotificationText(title) || "March";
+  const safeMessage = normalizeNotificationText(message) || "Turn finished";
+  const script = buildWindowsBalloonScript({ title: safeTitle, message: safeMessage });
+
+  try {
+    const child = spawnProcess("powershell.exe", [
+      "-NoProfile",
+      "-ExecutionPolicy", "Bypass",
+      "-WindowStyle", "Hidden",
+      "-Command", script,
+    ], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    child?.unref?.();
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, reason: err?.message ?? String(err) };
+  }
+}
+
+export function buildWindowsBalloonScript({ title, message, timeoutMs = DEFAULT_BALLOON_TIMEOUT_MS }) {
+  const escapedTitle = escapePowerShellSingleQuotedString(title);
+  const escapedMessage = escapePowerShellSingleQuotedString(message);
+  const timeout = Number.isFinite(timeoutMs) ? Math.max(0, Math.trunc(timeoutMs)) : DEFAULT_BALLOON_TIMEOUT_MS;
+  return [
+    "Add-Type -AssemblyName System.Windows.Forms",
+    "Add-Type -AssemblyName System.Drawing",
+    "$n = New-Object System.Windows.Forms.NotifyIcon",
+    "$n.Icon = [System.Drawing.SystemIcons]::Information",
+    `$n.BalloonTipTitle = '${escapedTitle}'`,
+    `$n.BalloonTipText = '${escapedMessage}'`,
+    "$n.Visible = $true",
+    `$n.ShowBalloonTip(${timeout})`,
+    `Start-Sleep -Milliseconds ${timeout + 500}`,
+    "$n.Dispose()",
+  ].join("; ");
+}
+
+function defaultTurnTitle(status) {
+  return status === "error" ? "March turn failed" : "March is ready";
+}
+
+function defaultTurnMessage(event) {
+  if (event?.status === "error") return event?.errorMessage ?? "Something went wrong";
+  return event?.sessionName ? `${event.sessionName} is ready for review` : "Your turn is ready for review";
+}
+
+function normalizeNotificationText(text) {
+  return String(text ?? "")
+    .replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 240);
+}
+
+function escapePowerShellSingleQuotedString(text) {
+  return String(text).replaceAll("'", "''");
+}

package/src/platform/open-file.mjs

@@ -0,0 +1,28 @@
+import { spawn } from "node:child_process";
+
+export function openFileWithDefaultApp(filePath) {
+  return new Promise((resolve, reject) => {
+    const { command, args } = openCommand(filePath);
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+
+function openCommand(filePath) {
+  if (process.platform === "win32") {
+    return {
+      command: "powershell.exe",
+      args: ["-NoProfile", "-Command", "Start-Process -LiteralPath $args[0]", filePath],
+    };
+  }
+
+  if (process.platform === "darwin") {
+    return { command: "open", args: [filePath] };
+  }
+
+  return { command: "xdg-open", args: [filePath] };
+}