pi-ui-extend 0.1.6 → 0.1.9

package/external/pi-tools-suite/src/lsp/client.ts

@@ -1,13 +1,16 @@
 import path from "node:path";
+import fs from "node:fs/promises";
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
 import type { MessageConnection } from "vscode-jsonrpc";
 import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node";
 import {
   DefinitionRequest,
+  DiagnosticRefreshRequest,
   DidChangeConfigurationNotification,
   DidChangeTextDocumentNotification,
   DidOpenTextDocumentNotification,
   DidSaveTextDocumentNotification,
+  DocumentDiagnosticRequest,
   DocumentSymbolRequest,
   ExecuteCommandRequest,
   HoverRequest,
@@ -16,6 +19,7 @@ import {
   PublishDiagnosticsNotification,
   ReferencesRequest,
   type Diagnostic,
+  type DocumentDiagnosticReport,
   type InitializeResult,
   type ServerCapabilities,
 } from "vscode-languageserver-protocol";
@@ -24,11 +28,38 @@ import { bestEffortWriteJsonRpc, isChildRunning, killChild, terminateChild } fro
 import { DEFAULT_STARTUP_TIMEOUT_MS, REQUEST_TIMEOUT_MS } from "./constants";
 import { DocumentStore } from "./documents";
 import type { DiagnosticsStore } from "./diagnostics-store";
-import { filePathToUri } from "./_shared/paths";
+import { filePathToUri, uriToFilePath } from "./_shared/paths";
 import { isExecutableAvailable } from "./_shared/runner";
 import type { LspServerConfig, ResolvedCommand } from "./_shared/types";
 import { supportsSave } from "./lsp-utils";
 import type { OpenDocument } from "./types";
+
+interface MarkdownToken {
+  type: string;
+  markup: string;
+  content: string;
+  map: number[] | null;
+  children: MarkdownToken[] | null;
+}
+
+function markdownTextToken(content: string): MarkdownToken {
+  return { type: "text", markup: "", content, map: null, children: null };
+}
+
+function parseMarkdownTokens(text: string): MarkdownToken[] {
+  const tokens: MarkdownToken[] = [];
+  const lines = text.split(/\r?\n/);
+  for (let lineNumber = 0; lineNumber < lines.length; lineNumber += 1) {
+    const line = lines[lineNumber];
+    const heading = /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(line);
+    if (!heading) continue;
+    const [, markup, content] = heading;
+    tokens.push({ type: "heading_open", markup, content: "", map: [lineNumber, lineNumber + 1], children: null });
+    tokens.push({ type: "inline", markup: "", content, map: [lineNumber, lineNumber + 1], children: [markdownTextToken(content.trim())] });
+    tokens.push({ type: "heading_close", markup, content: "", map: null, children: null });
+  }
+  return tokens;
+}
 import { tsserverDiagnosticToLsp, tsserverDiagnosticsFromResponse } from "./tsserver";
 
 export class LspClient {
@@ -40,6 +71,8 @@ export class LspClient {
   private initialized = false;
   private unavailableReason: string | undefined;
   private stderrTail = "";
+  private readonly dynamicDiagnosticProviders = new Map<string, string | undefined>();
+  private diagnosticProviderWaiters: Array<() => void> = [];
 
   constructor(
     private readonly server: LspServerConfig,
@@ -76,6 +109,7 @@ export class LspClient {
     const child = spawn(this.command.bin, this.command.args, {
       cwd: this.command.cwd,
       env: this.command.env ? { ...process.env, ...this.command.env } : process.env,
+      detached: process.platform !== "win32",
       shell: false,
       stdio: ["pipe", "pipe", "pipe"],
     });
@@ -113,6 +147,7 @@ export class LspClient {
       Promise.race([connection.sendRequest(InitializeRequest.method, this.initializeParams()), startupFailure]),
       this.server.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS,
       `${this.server.id} initialize`,
+      signal,
     )) as InitializeResult;
     this.capabilities = initializeResult.capabilities;
     failStartup = undefined;
@@ -136,10 +171,12 @@ export class LspClient {
         window: { workDoneProgress: true },
         workspace: {
           configuration: true,
+          diagnostics: { refreshSupport: true },
           workspaceFolders: true,
           didChangeWatchedFiles: { dynamicRegistration: true },
         },
         textDocument: {
+          diagnostic: { dynamicRegistration: true, relatedDocumentSupport: true },
           synchronization: {
             didOpen: true,
             didChange: true,
@@ -178,8 +215,67 @@ export class LspClient {
       return items.map(() => this.server.settings ?? {});
     });
     anyConnection.onRequest("workspace/workspaceFolders", () => [{ name: path.basename(this.root), uri: filePathToUri(this.root) }]);
-    anyConnection.onRequest("client/registerCapability", () => null);
-    anyConnection.onRequest("client/unregisterCapability", () => null);
+    anyConnection.onRequest("markdown/parse", async (params: unknown) => {
+      const request = params as { uri?: unknown; text?: unknown } | undefined;
+      const text = typeof request?.text === "string"
+        ? request.text
+        : typeof request?.uri === "string"
+          ? this.documents.get(uriToFilePath(request.uri))?.text ?? await fs.readFile(uriToFilePath(request.uri), "utf8")
+          : "";
+      return parseMarkdownTokens(text);
+    });
+    anyConnection.onRequest("markdown/fs/readFile", async (params: unknown) => {
+      const uri = (params as { uri?: unknown } | undefined)?.uri;
+      if (typeof uri !== "string") return [];
+      return [...await fs.readFile(uriToFilePath(uri))];
+    });
+    anyConnection.onRequest("markdown/fs/stat", async (params: unknown) => {
+      const uri = (params as { uri?: unknown } | undefined)?.uri;
+      if (typeof uri !== "string") return undefined;
+      try {
+        const stat = await fs.stat(uriToFilePath(uri));
+        return { isDirectory: stat.isDirectory() };
+      } catch {
+        return undefined;
+      }
+    });
+    anyConnection.onRequest("markdown/fs/readDirectory", async (params: unknown) => {
+      const uri = (params as { uri?: unknown } | undefined)?.uri;
+      if (typeof uri !== "string") return [];
+      try {
+        const entries = await fs.readdir(uriToFilePath(uri), { withFileTypes: true });
+        return entries.map((entry) => [entry.name, { isDirectory: entry.isDirectory() }]);
+      } catch {
+        return [];
+      }
+    });
+    anyConnection.onRequest("markdown/fs/watcher/create", () => null);
+    anyConnection.onRequest("markdown/fs/watcher/delete", () => null);
+    anyConnection.onRequest("markdown/findMarkdownFilesInWorkspace", () => []);
+    anyConnection.onRequest("client/registerCapability", (params: unknown) => {
+      const registrations = (params as { registrations?: unknown[] } | undefined)?.registrations;
+      if (!Array.isArray(registrations)) return null;
+
+      for (const registration of registrations) {
+        const item = registration as { id?: unknown; method?: unknown; registerOptions?: unknown };
+        if (typeof item.id !== "string" || item.method !== DocumentDiagnosticRequest.method) continue;
+        const options = item.registerOptions as { identifier?: unknown } | undefined;
+        this.dynamicDiagnosticProviders.set(item.id, typeof options?.identifier === "string" ? options.identifier : undefined);
+      }
+      this.resolveDiagnosticProviderWaiters();
+      return null;
+    });
+    anyConnection.onRequest("client/unregisterCapability", (params: unknown) => {
+      const unregisterations = (params as { unregisterations?: unknown[] } | undefined)?.unregisterations;
+      if (!Array.isArray(unregisterations)) return null;
+
+      for (const registration of unregisterations) {
+        const item = registration as { id?: unknown; method?: unknown };
+        if (typeof item.id === "string" && item.method === DocumentDiagnosticRequest.method) this.dynamicDiagnosticProviders.delete(item.id);
+      }
+      return null;
+    });
+    anyConnection.onRequest(DiagnosticRefreshRequest.method, () => null);
     anyConnection.onRequest("window/workDoneProgress/create", () => null);
     anyConnection.onNotification("window/logMessage", () => undefined);
     anyConnection.onNotification("telemetry/event", () => undefined);
@@ -226,7 +322,50 @@ export class LspClient {
     return Array.isArray(commands) && commands.includes("typescript.tsserverRequest");
   }
 
-  async tsserverDiagnostics(file: string, text: string, timeoutMs: number): Promise<Diagnostic[] | undefined> {
+  private supportsPullDiagnostics(): boolean {
+    return !!this.capabilities?.diagnosticProvider || this.dynamicDiagnosticProviders.size > 0;
+  }
+
+  private resolveDiagnosticProviderWaiters(): void {
+    const waiters = this.diagnosticProviderWaiters;
+    this.diagnosticProviderWaiters = [];
+    for (const waiter of waiters) waiter();
+  }
+
+  private async waitForPullDiagnosticsSupport(timeoutMs: number, signal?: AbortSignal): Promise<void> {
+    if (this.supportsPullDiagnostics() || timeoutMs <= 0) return;
+    await withTimeout(new Promise<void>((resolve) => {
+      this.diagnosticProviderWaiters.push(resolve);
+    }), timeoutMs, `${this.server.id} diagnostic registration`, signal).catch(() => undefined);
+  }
+
+  private diagnosticProviderIdentifiers(): Array<string | undefined> {
+    const identifiers: Array<string | undefined> = [];
+    const provider = this.capabilities?.diagnosticProvider;
+    if (provider) {
+      identifiers.push(
+        typeof provider === "object" && "identifier" in provider && typeof provider.identifier === "string"
+          ? provider.identifier
+          : undefined,
+      );
+    }
+    for (const identifier of this.dynamicDiagnosticProviders.values()) identifiers.push(identifier);
+
+    const seen = new Set<string>();
+    return identifiers.filter((identifier) => {
+      const key = identifier ?? "";
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
+  private diagnosticsFromReport(report: DocumentDiagnosticReport | null | undefined): Diagnostic[] | undefined {
+    if (!report || report.kind !== "full") return undefined;
+    return report.items;
+  }
+
+  async tsserverDiagnostics(file: string, text: string, timeoutMs: number, signal?: AbortSignal): Promise<Diagnostic[] | undefined> {
     const connection = this.connection;
     if (!connection || !this.supportsTsserverDiagnostics()) return undefined;
 
@@ -252,11 +391,51 @@ export class LspClient {
       }),
       timeoutMs,
       `${this.server.id} ${request.command}`,
+      signal,
     )));
 
     return responses.flatMap((response) => tsserverDiagnosticsFromResponse(response).map((diagnostic) => tsserverDiagnosticToLsp(diagnostic, text)));
   }
 
+  async pullDiagnostics(file: string, timeoutMs: number, signal?: AbortSignal): Promise<Diagnostic[] | undefined> {
+    const connection = this.connection;
+    if (!connection) return undefined;
+    if (!this.supportsPullDiagnostics()) {
+      await this.waitForPullDiagnosticsSupport(this.server.id === "csharp" ? Math.min(timeoutMs, 5_000) : 250, signal);
+    }
+    if (!this.supportsPullDiagnostics()) return undefined;
+    const identifiers = this.diagnosticProviderIdentifiers();
+    if (identifiers.length === 0) return undefined;
+
+    const uri = filePathToUri(file);
+    const settled = await Promise.allSettled(identifiers.map(async (identifier) => {
+      const report = (await withTimeout(
+        connection.sendRequest(DocumentDiagnosticRequest.method, {
+          textDocument: { uri },
+          identifier,
+        }),
+        timeoutMs,
+        `${this.server.id} textDocument/diagnostic${identifier ? ` (${identifier})` : ""}`,
+        signal,
+      )) as DocumentDiagnosticReport | null;
+      return this.diagnosticsFromReport(report) ?? [];
+    }));
+
+    const fulfilled = settled.filter((result): result is PromiseFulfilledResult<Diagnostic[]> => result.status === "fulfilled");
+    if (fulfilled.length === 0) {
+      const firstError = settled.find((result): result is PromiseRejectedResult => result.status === "rejected")?.reason;
+      throw firstError instanceof Error ? firstError : new Error(String(firstError ?? "pull diagnostics failed"));
+    }
+
+    const seen = new Set<string>();
+    return fulfilled.flatMap((result) => result.value).filter((diagnostic) => {
+      const key = JSON.stringify([diagnostic.range, diagnostic.severity, diagnostic.source, diagnostic.code, diagnostic.message]);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
   async hover(file: string, line: number, character: number): Promise<unknown> {
     if (!this.connection) throw new Error(`${this.server.id}: LSP connection unavailable`);
     return withTimeout(

package/external/pi-tools-suite/src/lsp/manager.ts

@@ -9,6 +9,7 @@ import { filePathToUri, findProjectRoot, normalizeRelativePath, resolveCommand,
 import { formatLspDiagnostics, formatWarnings, joinSections } from "./_shared/output";
 import type { LspServerConfig, StoredDiagnostics } from "./_shared/types";
 import { clientKey, couldMatchBeforeRoot, fileSizeAllowed, languageIdForFile, readTextFile } from "./lsp-utils";
+import { localMarkdownDiagnostics } from "./markdown-diagnostics";
 import type { MatchedServer } from "./types";
 
 function isFreshDiagnosticsEntry(entry: StoredDiagnostics | undefined, since: number, version: number | undefined): entry is StoredDiagnostics {
@@ -17,6 +18,27 @@ function isFreshDiagnosticsEntry(entry: StoredDiagnostics | undefined, since: nu
     && (entry.version === undefined || version === undefined || entry.version >= version);
 }
 
+function diagnosticsWithLocalFallback(serverId: string, file: string, text: string, diagnostics: StoredDiagnostics["diagnostics"]): StoredDiagnostics["diagnostics"] {
+  if (serverId !== "markdown") return diagnostics;
+  const hasLanguageServerLinkDiagnostics = diagnostics.some((diagnostic) => typeof diagnostic.code === "string" && diagnostic.code.startsWith("link."));
+  const localDiagnostics = localMarkdownDiagnostics(file, text).filter((diagnostic) => {
+    if (!hasLanguageServerLinkDiagnostics) return true;
+    return !(typeof diagnostic.code === "string" && diagnostic.code.startsWith("link."));
+  });
+  if (localDiagnostics.length === 0) return diagnostics;
+
+  const seen = new Set(diagnostics.map((diagnostic) => JSON.stringify([diagnostic.range, diagnostic.severity, diagnostic.source, diagnostic.code, diagnostic.message])));
+  return [
+    ...diagnostics,
+    ...localDiagnostics.filter((diagnostic) => {
+      const key = JSON.stringify([diagnostic.range, diagnostic.severity, diagnostic.source, diagnostic.code, diagnostic.message]);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    }),
+  ];
+}
+
 export class LspManager {
   private readonly diagnostics = new DiagnosticsStore();
   private readonly clients = new Map<string, LspClient>();
@@ -115,16 +137,30 @@ export class LspManager {
         // diagnostics don't degrade into a misleading publishDiagnostics timeout.
         let tsserverFallbackError: string | undefined;
         try {
-          const tsserverDiagnostics = await client.tsserverDiagnostics(file, text, diagnosticsWaitMs);
+          const tsserverDiagnostics = await client.tsserverDiagnostics(file, text, diagnosticsWaitMs, ctx.signal);
           if (tsserverDiagnostics !== undefined) {
-            this.diagnostics.set(match.server.id, match.root, filePathToUri(file), tsserverDiagnostics, doc.version);
-            lines.push(formatLspDiagnostics(match.server.id, file, tsserverDiagnostics, match.root));
+            const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, tsserverDiagnostics);
+            this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
+            lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
             continue;
           }
         } catch (error) {
           tsserverFallbackError = (error as Error).message;
         }
 
+        let pullDiagnosticsError: string | undefined;
+        try {
+          const pulledDiagnostics = await client.pullDiagnostics(file, diagnosticsWaitMs, ctx.signal);
+          if (pulledDiagnostics !== undefined) {
+            const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, pulledDiagnostics);
+            this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
+            lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
+            continue;
+          }
+        } catch (error) {
+          pullDiagnosticsError = (error as Error).message;
+        }
+
         const entry = await this.diagnostics.waitForFile(
           match.server.id,
           match.root,
@@ -136,10 +172,13 @@ export class LspManager {
         );
         if (!isFreshDiagnosticsEntry(entry, startedAt, doc.version)) {
           const fallbackSuffix = tsserverFallbackError ? `; tsserver fallback failed: ${tsserverFallbackError}` : "";
-          lines.push(`⚠️ ${match.server.id}: timed out after ${diagnosticsWaitMs}ms waiting for fresh diagnostics for ${match.relFile}${fallbackSuffix}`);
+          const pullSuffix = pullDiagnosticsError ? `; pull diagnostics failed: ${pullDiagnosticsError}` : "";
+          lines.push(`⚠️ ${match.server.id}: timed out after ${diagnosticsWaitMs}ms waiting for fresh diagnostics for ${match.relFile}${fallbackSuffix}${pullSuffix}`);
           continue;
         }
-        lines.push(formatLspDiagnostics(match.server.id, file, entry.diagnostics, match.root));
+        const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, entry.diagnostics);
+        if (diagnostics !== entry.diagnostics) this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
+        lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
       } catch (error) {
         lines.push(`⚠️ ${match.server.id}: ${(error as Error).message}`);
       }

package/external/pi-tools-suite/src/lsp/markdown-diagnostics.ts

@@ -0,0 +1,157 @@
+import path from "node:path";
+import fs from "node:fs";
+import type { Diagnostic } from "vscode-languageserver-protocol";
+
+interface LineOffsets {
+  readonly text: string;
+  readonly starts: number[];
+}
+
+function lineOffsets(text: string): LineOffsets {
+  const starts = [0];
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] === "\n") starts.push(index + 1);
+  }
+  return { text, starts };
+}
+
+function positionAt(offsets: LineOffsets, offset: number): { line: number; character: number } {
+  let low = 0;
+  let high = offsets.starts.length - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    if (offsets.starts[mid] <= offset) low = mid + 1;
+    else high = mid - 1;
+  }
+  const line = Math.max(0, high);
+  return { line, character: Math.max(0, offset - offsets.starts[line]) };
+}
+
+function diagnostic(offsets: LineOffsets, start: number, end: number, message: string, code: string, severity: Diagnostic["severity"] = 1): Diagnostic {
+  return {
+    severity,
+    source: "pi-markdown",
+    code,
+    message,
+    range: {
+      start: positionAt(offsets, start),
+      end: positionAt(offsets, Math.max(end, start + 1)),
+    },
+  };
+}
+
+function addMarkdownLinkDiagnostics(file: string, text: string, offsets: LineOffsets, out: Diagnostic[]): void {
+  const definitions = new Map<string, Array<{ start: number; end: number }>>();
+  const usedReferences = new Set<string>();
+
+  for (const match of text.matchAll(/^\s{0,3}\[([^\]\r\n]+)\]:\s*(\S+)/gm)) {
+    const ref = match[1].trim().toLocaleLowerCase();
+    const start = (match.index ?? 0) + match[0].indexOf(match[1]);
+    const end = start + match[1].length;
+    const existing = definitions.get(ref) ?? [];
+    existing.push({ start, end });
+    definitions.set(ref, existing);
+  }
+
+  for (const [ref, locations] of definitions) {
+    if (locations.length <= 1) continue;
+    for (const location of locations) {
+      out.push(diagnostic(offsets, location.start, location.end, `Duplicate link definition: '${ref}'`, "link.duplicate-definition", 2));
+    }
+  }
+
+  for (const match of text.matchAll(/(?<!!)(?:\[[^\]\r\n]+\]\[([^\]\r\n]*)\]|\[([^\]\r\n]+)\]\[\])/g)) {
+    const full = match[0];
+    const explicit = match[1];
+    const collapsed = match[2];
+    const ref = (explicit === "" ? collapsed : explicit)?.trim();
+    if (!ref) continue;
+    const normalized = ref.toLocaleLowerCase();
+    usedReferences.add(normalized);
+    if (definitions.has(normalized)) continue;
+    const start = (match.index ?? 0) + full.lastIndexOf(ref);
+    out.push(diagnostic(offsets, start, start + ref.length, `No link definition found: '${ref}'`, "link.no-such-reference"));
+  }
+
+  for (const [ref, locations] of definitions) {
+    if (usedReferences.has(ref)) continue;
+    for (const location of locations) {
+      out.push(diagnostic(offsets, location.start, location.end, "Link definition is unused", "link.unused-definition", 4));
+    }
+  }
+
+  const fileLinkPattern = /(?<!!)\[[^\]\r\n]+\]\(([^)\s]+)(?:\s+[^)]*)?\)/g;
+  for (const match of text.matchAll(fileLinkPattern)) {
+    const href = match[1];
+    if (!href || /^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith("#")) continue;
+    const [targetPath] = href.split("#", 1);
+    if (!targetPath || targetPath.startsWith("mailto:")) continue;
+    const decoded = decodeURIComponent(targetPath);
+    const absolute = path.resolve(path.dirname(file), decoded);
+    try {
+      if (!fs.existsSync(absolute)) {
+        const start = (match.index ?? 0) + match[0].indexOf(href);
+        out.push(diagnostic(offsets, start, start + href.length, `File does not exist: '${href}'`, "link.no-such-file"));
+      }
+    } catch {
+      // Ignore malformed/unsupported local paths.
+    }
+  }
+}
+
+const mermaidStarters = /^(?:---|graph\s+(?:TB|BT|RL|LR|TD)|flowchart\s+(?:TB|BT|RL|LR|TD)|sequenceDiagram|classDiagram(?:-v2)?|stateDiagram(?:-v2)?|erDiagram|journey|gantt|pie(?:\s+title\b)?|gitGraph|mindmap|timeline|quadrantChart|requirementDiagram|C4Context|C4Container|C4Component|C4Dynamic|sankey-beta|xyChart-beta|block-beta|packet-beta|architecture-beta)\b/i;
+
+function mermaidBlocks(text: string): Array<{ content: string; startOffset: number; fenceStart: number; fenceEnd: number }> {
+  const blocks: Array<{ content: string; startOffset: number; fenceStart: number; fenceEnd: number }> = [];
+  const fencePattern = /^(```|~~~)\s*(?:mermaid|mmd)\b[^\r\n]*\r?\n([\s\S]*?)^\1\s*$/gim;
+  for (const match of text.matchAll(fencePattern)) {
+    const fenceStart = match.index ?? 0;
+    const contentStart = fenceStart + match[0].indexOf(match[2]);
+    blocks.push({ content: match[2], startOffset: contentStart, fenceStart, fenceEnd: fenceStart + match[0].length });
+  }
+  return blocks;
+}
+
+function addMermaidDiagnostics(file: string, text: string, offsets: LineOffsets, out: Diagnostic[]): void {
+  const extension = path.extname(file).toLocaleLowerCase();
+  const blocks = [".mmd", ".mermaid"].includes(extension)
+    ? [{ content: text, startOffset: 0, fenceStart: 0, fenceEnd: text.length }]
+    : mermaidBlocks(text);
+
+  for (const block of blocks) {
+    const lines = block.content.split(/\r?\n/);
+    const firstIndex = lines.findIndex((line) => {
+      const trimmed = line.trim();
+      return trimmed.length > 0 && !trimmed.startsWith("%%");
+    });
+    if (firstIndex === -1) {
+      out.push(diagnostic(offsets, block.fenceStart, block.fenceEnd, "Mermaid diagram is empty", "mermaid.empty"));
+      continue;
+    }
+
+    const beforeFirst = lines.slice(0, firstIndex).join("\n");
+    const firstOffset = block.startOffset + (beforeFirst ? beforeFirst.length + 1 : 0) + (lines[firstIndex].match(/^\s*/)?.[0].length ?? 0);
+    const firstLine = lines[firstIndex].trim();
+    if (!mermaidStarters.test(firstLine)) {
+      out.push(diagnostic(offsets, firstOffset, firstOffset + firstLine.length, "Mermaid diagram should start with a supported diagram type such as 'flowchart TD'", "mermaid.missing-diagram-type"));
+      continue;
+    }
+
+    let runningOffset = block.startOffset;
+    for (const line of lines) {
+      const arrow = /\b[A-Za-z0-9_]+\s*->\s*[A-Za-z0-9_]+\b/.exec(line);
+      if (arrow) {
+        out.push(diagnostic(offsets, runningOffset + arrow.index, runningOffset + arrow.index + arrow[0].length, "Mermaid flowchart arrows use '-->' or another Mermaid arrow form, not '->'", "mermaid.invalid-arrow"));
+      }
+      runningOffset += line.length + 1;
+    }
+  }
+}
+
+export function localMarkdownDiagnostics(file: string, text: string): Diagnostic[] {
+  const offsets = lineOffsets(text);
+  const diagnostics: Diagnostic[] = [];
+  addMarkdownLinkDiagnostics(file, text, offsets, diagnostics);
+  addMermaidDiagnostics(file, text, offsets, diagnostics);
+  return diagnostics;
+}

package/external/pi-tools-suite/src/opencode-import/commands.ts

@@ -0,0 +1,86 @@
+import type { OpencodeImportOptions, OpencodeImportResult, OpencodeProviderImportResult } from "./importer";
+
+function tokenizeArgs(args: string): string[] {
+	return args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((part) => part.replace(/^("|')|("|')$/g, "")) ?? [];
+}
+
+export function parseOpencodeImportCommandArgs(args: string): OpencodeImportOptions {
+	const tokens = tokenizeArgs(args);
+	const parsed: OpencodeImportOptions = {};
+	for (let i = 0; i < tokens.length; i += 1) {
+		const token = tokens[i];
+		if (token === "--force" || token === "-f") {
+			parsed.overwrite = true;
+		} else if ((token === "--path" || token === "--opencode-auth-path") && tokens[i + 1]) {
+			parsed.sourcePath = tokens[++i];
+		} else if (token === "--auth-path" && tokens[i + 1]) {
+			parsed.authPath = tokens[++i];
+		} else if (token === "--antigravity-path" && tokens[i + 1]) {
+			parsed.antigravitySourcePath = tokens[++i];
+		} else if (token === "--skip-auth-json") {
+			parsed.skipAuthJson = true;
+		} else if (token === "--skip-antigravity") {
+			parsed.skipAntigravity = true;
+		} else if ((token === "--antigravity-index" || token === "--antigravity-account-index") && tokens[i + 1]) {
+			const index = Number(tokens[++i]);
+			if (Number.isInteger(index)) parsed.antigravityAccountIndex = index;
+		} else if (token === "--antigravity-email" && tokens[i + 1]) {
+			parsed.antigravityEmail = tokens[++i];
+		} else if (!token.startsWith("-") && !parsed.sourcePath) {
+			parsed.sourcePath = token;
+		}
+	}
+	return parsed;
+}
+
+function statusText(result: OpencodeProviderImportResult): string {
+	switch (result.status) {
+		case "imported":
+			return `imported ${result.sourceProvider} → ${result.targetProvider}`;
+		case "already-imported":
+			return `already imported ${result.targetProvider}`;
+		case "auth-exists-use-force":
+			return `skipped ${result.targetProvider}: already exists; use --force`;
+		case "target-set-from-other-source":
+			return `skipped ${result.sourceProvider}: ${result.targetProvider} was already filled from another opencode entry`;
+		case "invalid-source":
+			return `skipped ${result.sourceProvider}: missing usable token/key`;
+		case "source-missing":
+			return `missing ${result.sourceProvider}`;
+	}
+}
+
+function antigravityText(result: OpencodeImportResult): string | undefined {
+	const antigravity = result.antigravity;
+	if (!antigravity) return undefined;
+	const account = antigravity.email ? ` ${antigravity.email}` : "";
+	const position = typeof antigravity.accountIndex === "number" && typeof antigravity.accountCount === "number" ? ` (${antigravity.accountIndex + 1}/${antigravity.accountCount})` : "";
+	if (antigravity.imported) {
+		return `Antigravity: imported${account}${position}${antigravity.overwroteExisting ? " and overwrote existing auth" : ""}`;
+	}
+	if (antigravity.reason === "auth-exists-use-force") return "Antigravity: skipped existing auth; use --force";
+	if (antigravity.reason === "already-imported") return `Antigravity: already imported${account}${position}`;
+	return `Antigravity: skipped (${antigravity.reason ?? "unknown"})`;
+}
+
+export function formatOpencodeImportResult(result: OpencodeImportResult): string {
+	const providerLines = result.providers
+		.filter((provider) => provider.status !== "source-missing")
+		.map((provider) => `- ${provider.label}: ${statusText(provider)}`);
+	const missingCount = result.providers.filter((provider) => provider.status === "source-missing").length;
+	const antigravity = antigravityText(result);
+	if (antigravity) providerLines.push(`- ${antigravity}`);
+
+	if (providerLines.length === 0) {
+		return `No opencode credentials were imported. Checked ${result.sourcePath}${result.antigravitySourcePath ? ` and ${result.antigravitySourcePath}` : ""}.`;
+	}
+
+	const suffix = missingCount > 0 ? `\nMissing ${missingCount} known opencode provider entr${missingCount === 1 ? "y" : "ies"}.` : "";
+	return `Opencode import wrote to ${result.authPath}:\n${providerLines.join("\n")}${suffix}`;
+}
+
+export function notificationLevel(result: OpencodeImportResult): "info" | "warn" | "error" {
+	if (result.wroteAuth) return "info";
+	if (result.providers.some((provider) => provider.status === "auth-exists-use-force") || result.antigravity?.reason === "auth-exists-use-force") return "warn";
+	return "error";
+}