@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/storage/backends/fortemi.js

@@ -0,0 +1,227 @@
+/**
+ * Fortemi Storage Adapter
+ *
+ * Routes storage operations through Fortemi's MCP tool surface. Fortemi
+ * is the first-party AIWG semantic-memory project — Rust + PostgreSQL +
+ * pgvector + SKOS + W3C PROV — referenced as "Forte" in #934 and
+ * confirmed as Fortemi in #961.
+ *
+ * Tool surface (per `.aiwg/planning/training-framework/phase-4-fortemi-review.md`):
+ *   capture_knowledge  - create note (we use this for first writes)
+ *   update_note        - revise existing note (we use this for re-writes)
+ *   get_note           - retrieve full note (read)
+ *   list_notes         - filter/paginate (list)
+ *   search             - text/semantic/spatial/temporal search (query)
+ *   manage_collection  - organize notes in folders (we use folder=subsystem
+ *                        scope to mirror the StorageAdapter contract)
+ *
+ * Path semantics:
+ *   note_id = `${subsystem}:${path}` — the adapter passes the
+ *   subsystem-relative path; the registry-supplied `subsystem` is
+ *   prepended to keep different subsystems' notes from colliding.
+ *
+ * Caveats:
+ *   - This adapter ships with the parameter shapes documented in the
+ *     planning doc, but those shapes have NOT yet been validated against
+ *     a live Fortemi instance. Treat this as alpha. The
+ *     `McpClientLike.callTool(name, args)` injection point lets tests
+ *     stub freely; real-world parameter mismatches surface as MCP
+ *     errors that bubble up to the consumer.
+ *   - Delete is implemented via `update_note` with `archived: true`
+ *     because Fortemi's MCP surface does not document a direct delete
+ *     tool (immutability + versioning is core to the design).
+ *
+ * @design @.aiwg/architecture/storage-design.md (§5.6)
+ * @issue #934
+ * @issue #961
+ * @issue #972
+ */
+const DEFAULT_MCP_SERVER = 'fortemi';
+export class FortemiAdapter {
+    subsystem;
+    mcpServer;
+    scheme;
+    clientFactory;
+    client = null;
+    constructor(opts) {
+        this.subsystem = opts.subsystem;
+        this.mcpServer = opts.config.mcpServer ?? DEFAULT_MCP_SERVER;
+        this.scheme = opts.config.scheme;
+        this.clientFactory = opts.clientFactory ?? createDefaultMcpClient;
+    }
+    async init() {
+        if (this.client)
+            return;
+        this.client = await this.clientFactory(this.mcpServer);
+    }
+    async close() {
+        if (this.client?.close) {
+            await this.client.close();
+        }
+        this.client = null;
+    }
+    async getClient() {
+        if (!this.client)
+            await this.init();
+        if (!this.client) {
+            throw new Error(`storage(fortemi): MCP client unavailable for server "${this.mcpServer}"`);
+        }
+        return this.client;
+    }
+    noteId(path) {
+        if (typeof path !== 'string' || path.length === 0) {
+            throw new Error('storage(fortemi): path must be a non-empty string');
+        }
+        if (path.includes('\0')) {
+            throw new Error(`storage(fortemi): null bytes not allowed in path "${path}"`);
+        }
+        return `${this.subsystem}:${path}`;
+    }
+    async read(path) {
+        const id = this.noteId(path);
+        const client = await this.getClient();
+        const result = (await client.callTool('get_note', { note_id: id }));
+        if (!result || result.not_found)
+            return null;
+        const note = result.note;
+        if (!note)
+            return null;
+        return note.revised_content ?? note.content ?? null;
+    }
+    async write(path, content, meta) {
+        const id = this.noteId(path);
+        const client = await this.getClient();
+        // Try update first; if not found, capture as new. Two calls in the
+        // worst case but idempotent — Fortemi's update_note increments the
+        // version rather than overwriting, which matches the Phase-4 design.
+        const existing = (await client.callTool('get_note', { note_id: id }));
+        if (existing && !existing.not_found && existing.note) {
+            await client.callTool('update_note', {
+                note_id: id,
+                content,
+                metadata: this.buildMetadata(meta),
+            });
+        }
+        else {
+            await client.callTool('capture_knowledge', {
+                note_id: id,
+                content,
+                scheme: this.scheme,
+                metadata: this.buildMetadata(meta),
+            });
+        }
+    }
+    async list(prefix) {
+        if (typeof prefix !== 'string') {
+            throw new Error('storage(fortemi): list prefix must be a string');
+        }
+        const client = await this.getClient();
+        const subsystemPrefix = `${this.subsystem}:`;
+        const fullPrefix = prefix.length === 0 ? subsystemPrefix : `${subsystemPrefix}${prefix}`;
+        const result = (await client.callTool('list_notes', {
+            id_prefix: fullPrefix,
+            scheme: this.scheme,
+        }));
+        const notes = result?.notes ?? [];
+        return notes
+            .filter((n) => typeof n.note_id === 'string' && n.note_id.startsWith(subsystemPrefix))
+            .map((n) => {
+            const entry = {
+                path: n.note_id.slice(subsystemPrefix.length),
+                externalId: n.note_id,
+            };
+            if (typeof n.size === 'number')
+                entry.size = n.size;
+            if (typeof n.updated_at === 'string') {
+                const d = new Date(n.updated_at);
+                if (!Number.isNaN(d.getTime()))
+                    entry.modifiedAt = d;
+            }
+            return entry;
+        });
+    }
+    async delete(path) {
+        // Fortemi's MCP surface does not document a destructive delete —
+        // immutability + versioning is core to the design. We mark the note
+        // archived via update_note instead. This matches the storage-design
+        // contract (delete is "no-op when missing"; here we just suppress
+        // the note from list/read by archiving it).
+        const id = this.noteId(path);
+        const client = await this.getClient();
+        const existing = (await client.callTool('get_note', { note_id: id }));
+        if (!existing || existing.not_found || !existing.note)
+            return;
+        await client.callTool('update_note', {
+            note_id: id,
+            archived: true,
+        });
+    }
+    async query(q) {
+        const client = await this.getClient();
+        const subsystemPrefix = `${this.subsystem}:`;
+        const result = (await client.callTool('search', {
+            query: q,
+            id_prefix: subsystemPrefix,
+            scheme: this.scheme,
+        }));
+        const results = result?.results ?? [];
+        return results
+            .filter((r) => typeof r.note_id === 'string' && r.note_id.startsWith(subsystemPrefix))
+            .map((r) => ({
+            path: r.note_id.slice(subsystemPrefix.length),
+            externalId: r.note_id,
+        }));
+    }
+    buildMetadata(meta) {
+        const out = {
+            subsystem: this.subsystem,
+            source: 'aiwg-storage-adapter',
+        };
+        if (meta?.contentType)
+            out['content_type'] = meta.contentType;
+        if (meta?.frontmatter)
+            out['frontmatter'] = meta.frontmatter;
+        if (this.scheme)
+            out['scheme'] = this.scheme;
+        return out;
+    }
+}
+/**
+ * Default MCP client factory. Resolves the server config from AIWG's
+ * McpServerRegistry, spawns the stdio transport, and returns a
+ * connected client.
+ *
+ * Implemented as a lazy import so tests that inject a stub never load
+ * the SDK or touch the registry.
+ */
+export const createDefaultMcpClient = async (serverName) => {
+    const { McpServerRegistry } = await import('../../mcp/registry.js');
+    const registry = new McpServerRegistry();
+    const server = await registry.get(serverName);
+    if (!server) {
+        throw new Error(`storage(fortemi): MCP server "${serverName}" is not registered. ` +
+            `Add it via "aiwg mcp add ${serverName} --command <cmd>" before using the fortemi backend.`);
+    }
+    if (server.type !== 'stdio') {
+        throw new Error(`storage(fortemi): only stdio MCP servers are supported (got "${server.type}" for "${serverName}")`);
+    }
+    // Lazy import the SDK so tests that inject a stub don't pay the cost
+    const { Client } = await import('@modelcontextprotocol/sdk/client/index.js');
+    const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js');
+    const transport = new StdioClientTransport({
+        command: server.command ?? '',
+        args: server.args ?? [],
+        env: server.env,
+    });
+    const client = new Client({ name: 'aiwg-storage-fortemi-adapter', version: '1.0.0' }, { capabilities: {} });
+    await client.connect(transport);
+    return {
+        async callTool(name, args) {
+            return client.callTool({ name, arguments: args });
+        },
+        async close() {
+            await client.close();
+        },
+    };
+};
+//# sourceMappingURL=fortemi.js.map

package/dist/src/storage/backends/fs.js

@@ -0,0 +1,134 @@
+/**
+ * Filesystem Storage Adapter
+ *
+ * The default backend. Wraps `fs.promises` and honors per-subsystem root
+ * overrides from `storage.config`. Output is byte-identical to the
+ * pre-abstraction direct-fs calls so consumer migrations stay safe.
+ *
+ * @design @.aiwg/architecture/storage-design.md (§5.1)
+ * @issue #934
+ * @issue #956
+ */
+import { existsSync } from 'fs';
+import { appendFile, mkdir, readFile, readdir, rm, stat, writeFile } from 'fs/promises';
+import { dirname, join, relative, resolve, sep } from 'path';
+export class FilesystemAdapter {
+    /** Absolute path where this subsystem's content lives. */
+    root;
+    constructor(root) {
+        this.root = resolve(root);
+    }
+    /**
+     * Path traversal guard. Rejects `..`, leading `/`, leading `~`, and
+     * backslashes (which on POSIX would be treated as filename chars but
+     * are almost always a Windows-vs-POSIX bug). Also rejects empty paths.
+     */
+    resolveSafe(relPath) {
+        if (typeof relPath !== 'string' || relPath.length === 0) {
+            throw new Error('storage(fs): path must be a non-empty string');
+        }
+        if (relPath.includes('\\')) {
+            throw new Error(`storage(fs): backslash not allowed in path "${relPath}"`);
+        }
+        if (relPath.startsWith('/') || relPath.startsWith('~')) {
+            throw new Error(`storage(fs): absolute paths not allowed: "${relPath}"`);
+        }
+        const segments = relPath.split('/');
+        if (segments.some((s) => s === '..')) {
+            throw new Error(`storage(fs): ".." traversal not allowed in "${relPath}"`);
+        }
+        const abs = resolve(this.root, relPath);
+        // Final guard: ensure the resolved path is still under root, even if
+        // the segment check missed something unusual (e.g. empty segments).
+        if (abs !== this.root && !abs.startsWith(this.root + sep)) {
+            throw new Error(`storage(fs): resolved path escapes subsystem root: "${relPath}"`);
+        }
+        return abs;
+    }
+    async read(path) {
+        const abs = this.resolveSafe(path);
+        if (!existsSync(abs))
+            return null;
+        return readFile(abs, 'utf-8');
+    }
+    async write(path, content, _meta) {
+        const abs = this.resolveSafe(path);
+        await mkdir(dirname(abs), { recursive: true });
+        await writeFile(abs, content, 'utf-8');
+    }
+    /**
+     * Atomic append. Uses fs.appendFile, which opens with O_APPEND so the
+     * kernel guarantees atomicity for writes ≤ PIPE_BUF (4096 bytes on
+     * Linux). Concurrent appenders interleave at line granularity rather
+     * than racing read-then-write. See #976.
+     */
+    async append(path, content) {
+        const abs = this.resolveSafe(path);
+        await mkdir(dirname(abs), { recursive: true });
+        await appendFile(abs, content, 'utf-8');
+    }
+    async list(prefix) {
+        // Empty prefix = list everything under root. A non-empty prefix
+        // restricts to entries whose subsystem-relative path starts with it
+        // (after path-normalizing the prefix itself).
+        if (typeof prefix !== 'string') {
+            throw new Error('storage(fs): list prefix must be a string');
+        }
+        if (prefix.length > 0) {
+            // resolveSafe also validates the prefix shape
+            this.resolveSafe(prefix);
+        }
+        if (!existsSync(this.root))
+            return [];
+        const out = [];
+        await walkInto(this.root, this.root, prefix, out);
+        return out;
+    }
+    async delete(path) {
+        const abs = this.resolveSafe(path);
+        if (!existsSync(abs))
+            return;
+        await rm(abs, { force: true });
+    }
+}
+async function walkInto(root, dir, prefix, out) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        const full = join(dir, e.name);
+        const rel = relative(root, full).split(sep).join('/');
+        if (e.isDirectory()) {
+            // Descend if the dir could contain matches
+            if (prefix === '' || rel.startsWith(prefix) || prefix.startsWith(rel + '/')) {
+                await walkInto(root, full, prefix, out);
+            }
+            continue;
+        }
+        if (!e.isFile())
+            continue;
+        if (prefix !== '' && !rel.startsWith(prefix))
+            continue;
+        let size;
+        let modifiedAt;
+        try {
+            const s = await stat(full);
+            size = s.size;
+            modifiedAt = s.mtime;
+        }
+        catch {
+            // ignore stat failures
+        }
+        const entry = { path: rel };
+        if (size !== undefined)
+            entry.size = size;
+        if (modifiedAt !== undefined)
+            entry.modifiedAt = modifiedAt;
+        out.push(entry);
+    }
+}
+//# sourceMappingURL=fs.js.map

package/dist/src/storage/backends/logseq.js

@@ -0,0 +1,309 @@
+/**
+ * Logseq Storage Adapter
+ *
+ * Writes and reads markdown files in a Logseq graph on disk. Like the
+ * Obsidian adapter, this is filesystem-shaped — Logseq graphs are
+ * directories of `.md` (or `.org`) files plus a `logseq/` config dir
+ * we never touch.
+ *
+ * About the Logseq HTTP API: as of April 2025 the DB-backed Logseq
+ * rewrite is still in development; file-backed graphs remain primary.
+ * Logseq exposes an HTTP API at `http://127.0.0.1:12315/api` (with a
+ * bearer token issued from Settings → Features → Developer mode), but
+ * verifying its exact command surface requires hands-on Logseq access.
+ *
+ * What this adapter does:
+ *   - Reads / writes / lists / deletes markdown files via fs
+ *   - Optional HTTP API reachability probe (when `useApi: true`) —
+ *     emits a one-time stderr warning if `LOGSEQ_API_TOKEN` is unset or
+ *     the API is unreachable
+ *   - Refuses paths into the graph's `logseq/` config directory
+ *   - Transforms `WriteMeta.frontmatter` from YAML into Logseq's
+ *     page-level `property:: value` syntax
+ *   - Never writes block IDs (`id::`) — Logseq auto-assigns them
+ *
+ * Path layout (mirrors Logseq's on-disk conventions):
+ *   pages/<title>.md          regular pages
+ *   journals/YYYY_MM_DD.md    journal entries
+ *   logseq/*                  REFUSED (Logseq config)
+ *
+ * @design @.aiwg/architecture/storage-design.md (§5.3)
+ * @issue #934
+ * @issue #958
+ */
+import { existsSync } from 'fs';
+import { mkdir, readFile, readdir, rm, stat, writeFile } from 'fs/promises';
+import { dirname, join, relative, resolve, sep } from 'path';
+const LOGSEQ_CONFIG_DIR = 'logseq';
+const DEFAULT_API_URL = 'http://127.0.0.1:12315/api';
+export class LogseqAdapter {
+    /** Absolute path to the Logseq graph root. */
+    graph;
+    apiUrl;
+    useApi;
+    apiWarned = false;
+    constructor(config) {
+        this.graph = resolve(expandHome(config.graph));
+        this.apiUrl = config.apiUrl ?? DEFAULT_API_URL;
+        this.useApi = config.useApi ?? true;
+    }
+    async init() {
+        if (!existsSync(this.graph)) {
+            throw new Error(`storage(logseq): graph does not exist: ${this.graph}`);
+        }
+        if (this.useApi)
+            await this.probeApi();
+    }
+    /**
+     * One-shot API reachability probe. Warns once on missing token or
+     * unreachable endpoint. Direct fs writes still work without it.
+     */
+    async probeApi() {
+        if (this.apiWarned)
+            return;
+        const token = process.env['LOGSEQ_API_TOKEN'];
+        if (!token) {
+            this.apiWarned = true;
+            process.stderr.write(`storage(logseq): API requested (useApi: true) but LOGSEQ_API_TOKEN is not set.\n` +
+                `  AIWG will continue with direct file writes against the graph.\n` +
+                `  Set LOGSEQ_API_TOKEN (Settings → Features → Developer mode) or set "useApi": false to suppress.\n`);
+            return;
+        }
+        try {
+            // Lightweight reachability probe — most Logseq API servers respond
+            // to a simple POST. We don't synthesize a specific command; just
+            // confirm the endpoint is reachable.
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 2000);
+            try {
+                await fetch(this.apiUrl, {
+                    method: 'POST',
+                    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ method: 'logseq.App.getCurrentGraph' }),
+                    signal: controller.signal,
+                });
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }
+        catch {
+            this.apiWarned = true;
+            process.stderr.write(`storage(logseq): API server at ${this.apiUrl} is not reachable.\n` +
+                `  AIWG will continue with direct file writes against the graph.\n` +
+                `  Start Logseq with the API server enabled, or set "useApi": false to suppress.\n`);
+        }
+    }
+    /**
+     * Validate a subsystem-relative path. Rejects traversal, absolute
+     * paths, backslashes, and any path inside the graph's `logseq/` dir.
+     */
+    resolveSafe(relPath) {
+        if (typeof relPath !== 'string' || relPath.length === 0) {
+            throw new Error('storage(logseq): path must be a non-empty string');
+        }
+        if (relPath.includes('\\')) {
+            throw new Error(`storage(logseq): backslash not allowed in path "${relPath}"`);
+        }
+        if (relPath.startsWith('/') || relPath.startsWith('~')) {
+            throw new Error(`storage(logseq): absolute paths not allowed: "${relPath}"`);
+        }
+        const segments = relPath.split('/');
+        if (segments.some((s) => s === '..')) {
+            throw new Error(`storage(logseq): ".." traversal not allowed in "${relPath}"`);
+        }
+        const abs = resolve(this.graph, relPath);
+        if (abs !== this.graph && !abs.startsWith(this.graph + sep)) {
+            throw new Error(`storage(logseq): resolved path escapes graph root: "${relPath}"`);
+        }
+        const relFromGraph = relative(this.graph, abs);
+        if (relFromGraph === LOGSEQ_CONFIG_DIR ||
+            relFromGraph.startsWith(LOGSEQ_CONFIG_DIR + sep)) {
+            throw new Error(`storage(logseq): refusing to operate on logseq/ graph config (${relPath})`);
+        }
+        return abs;
+    }
+    async read(path) {
+        const abs = this.resolveSafe(path);
+        if (!existsSync(abs))
+            return null;
+        return readFile(abs, 'utf-8');
+    }
+    async write(path, content, meta) {
+        const abs = this.resolveSafe(path);
+        await mkdir(dirname(abs), { recursive: true });
+        let body = content;
+        // Strip YAML frontmatter from the content (if any) — Logseq doesn't
+        // recognize it. Move what we can to page-level properties.
+        const yaml = extractYamlFrontmatter(body);
+        if (yaml) {
+            body = yaml.body;
+        }
+        // Merge supplied frontmatter + extracted YAML into Logseq page-properties
+        const merged = { ...(yaml?.fields ?? {}), ...(meta?.frontmatter ?? {}) };
+        if (Object.keys(merged).length > 0) {
+            body = renderPageProperties(merged) + body;
+        }
+        // Defensive: refuse to write `id::` block IDs ourselves. Logseq
+        // auto-assigns them; if the caller smuggled one in, strip it.
+        body = body.replace(/^\s*id::\s*[^\n]+\n/gm, '');
+        await writeFile(abs, body, 'utf-8');
+    }
+    async list(prefix) {
+        if (typeof prefix !== 'string') {
+            throw new Error('storage(logseq): list prefix must be a string');
+        }
+        if (prefix.length > 0)
+            this.resolveSafe(prefix);
+        if (!existsSync(this.graph))
+            return [];
+        const out = [];
+        await walkInto(this.graph, this.graph, prefix, out);
+        return out;
+    }
+    async delete(path) {
+        const abs = this.resolveSafe(path);
+        if (!existsSync(abs))
+            return;
+        await rm(abs, { force: true });
+    }
+}
+async function walkInto(root, dir, prefix, out) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        // Skip the graph config directory at the root level
+        if (e.name === LOGSEQ_CONFIG_DIR && dir === root)
+            continue;
+        const full = join(dir, e.name);
+        const rel = relative(root, full).split(sep).join('/');
+        if (e.isDirectory()) {
+            if (prefix === '' || rel.startsWith(prefix) || prefix.startsWith(rel + '/')) {
+                await walkInto(root, full, prefix, out);
+            }
+            continue;
+        }
+        if (!e.isFile())
+            continue;
+        if (prefix !== '' && !rel.startsWith(prefix))
+            continue;
+        let size;
+        let modifiedAt;
+        try {
+            const s = await stat(full);
+            size = s.size;
+            modifiedAt = s.mtime;
+        }
+        catch {
+            // ignore
+        }
+        const entry = { path: rel };
+        if (size !== undefined)
+            entry.size = size;
+        if (modifiedAt !== undefined)
+            entry.modifiedAt = modifiedAt;
+        out.push(entry);
+    }
+}
+function expandHome(p) {
+    if (p.startsWith('~/')) {
+        const { homedir } = require('os');
+        return join(homedir(), p.slice(2));
+    }
+    if (p === '~') {
+        const { homedir } = require('os');
+        return homedir();
+    }
+    return p;
+}
+/**
+ * If `content` starts with a `---` YAML block, parse the block and
+ * return the parsed fields plus the body without the YAML. Otherwise
+ * return null.
+ *
+ * Minimal parser — handles `key: value` and `key: [a, b, c]` lines.
+ * Anything more complex falls back to dropping the value as a string.
+ */
+function extractYamlFrontmatter(content) {
+    const match = /^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?([\s\S]*)$/.exec(content);
+    if (!match)
+        return null;
+    const [, yamlBody, body] = match;
+    const fields = {};
+    for (const line of yamlBody.split(/\r?\n/)) {
+        if (line.trim().length === 0 || line.trim().startsWith('#'))
+            continue;
+        const m = /^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line);
+        if (!m)
+            continue;
+        const [, k, rawV] = m;
+        fields[k] = parseYamlScalar(rawV.trim());
+    }
+    return { fields, body };
+}
+function parseYamlScalar(raw) {
+    if (raw === '')
+        return '';
+    if (raw === 'true')
+        return true;
+    if (raw === 'false')
+        return false;
+    if (raw === 'null' || raw === '~')
+        return null;
+    if (/^-?\d+$/.test(raw))
+        return Number(raw);
+    if (/^-?\d+\.\d+$/.test(raw))
+        return Number(raw);
+    // Quoted string
+    if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))) {
+        try {
+            return JSON.parse(raw.replace(/^'/, '"').replace(/'$/, '"'));
+        }
+        catch {
+            return raw.slice(1, -1);
+        }
+    }
+    // Inline array
+    if (raw.startsWith('[') && raw.endsWith(']')) {
+        return raw
+            .slice(1, -1)
+            .split(',')
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0)
+            .map(parseYamlScalar);
+    }
+    return raw;
+}
+/**
+ * Render a flat object as Logseq page-level properties:
+ *
+ *   tags:: ai, note
+ *   created:: 2026-04-28
+ *
+ *   <body follows here>
+ */
+function renderPageProperties(fields) {
+    const lines = [];
+    for (const [k, v] of Object.entries(fields)) {
+        lines.push(`${k}:: ${formatLogseqValue(v)}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function formatLogseqValue(v) {
+    if (v === null || v === undefined)
+        return '';
+    if (typeof v === 'boolean' || typeof v === 'number')
+        return String(v);
+    if (Array.isArray(v))
+        return v.map((x) => formatLogseqValue(x)).join(', ');
+    if (typeof v === 'string')
+        return v;
+    return JSON.stringify(v);
+}
+//# sourceMappingURL=logseq.js.map