@parall/cli 1.33.0 → 1.35.0

package/dist/lib/wiki-tools.js

@@ -0,0 +1,540 @@
+import * as z from 'zod/v4';
+import { resolveRuntimeContext } from './client.js';
+import { getWikiBlob, getWikiChangesetDiff, getWikiOutline, getWikiSection, getWikiTree, getWikiWorkspaceDiff, getWikiWorkspaceStatus, listWikis, proposeWikiChangeset, queryWiki, searchWiki, } from './wiki.js';
+/** Pretty-print a value as 2-space-indented JSON for a tool's human-readable `text` field. */
+function jsonText(value) {
+    return JSON.stringify(value, null, 2);
+}
+/**
+ * Wrap a tool definition so its handler validates raw args against the tool's
+ * `inputSchema` before running. Returns a copy with the handler replaced; the
+ * wrapped handler throws a Zod parse error on invalid/missing input.
+ */
+function finalizeWikiTool(tool) {
+    const inputParser = z.object(tool.inputSchema);
+    return {
+        ...tool,
+        handler: async (args) => tool.handler(inputParser.parse(args ?? {})),
+    };
+}
+/**
+ * Build the full wiki native tool registry bound to a Parall context (credentials,
+ * agent env, local mount). Returns one definition per wiki capability (list, tree,
+ * status, diff, blob, search, query, outline, section, changeset diff, propose),
+ * each finalized with input validation. Shared by the MCP server and the eval harness.
+ */
+export function buildWikiTools(ctx) {
+    const tools = [
+        {
+            name: 'wiki_list',
+            title: 'List Parall Wikis',
+            description: 'List Parall wiki repositories that the current credentials can access.',
+            readOnly: true,
+            inputSchema: {},
+            outputSchema: {
+                wikis: z.array(z.object({
+                    id: z.string(),
+                    slug: z.string(),
+                    name: z.string(),
+                    default_branch: z.string(),
+                })),
+            },
+            handler: async () => {
+                const wikis = await listWikis(ctx);
+                const structuredContent = {
+                    wikis: wikis.map((wiki) => ({
+                        id: wiki.id,
+                        slug: wiki.slug,
+                        name: wiki.name,
+                        default_branch: wiki.default_branch,
+                    })),
+                };
+                return {
+                    text: jsonText(structuredContent),
+                    structuredContent,
+                };
+            },
+        },
+        {
+            name: 'wiki_tree',
+            title: 'Browse Wiki Tree',
+            description: 'List files and folders under a Parall wiki path.',
+            readOnly: true,
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                path: z.string().optional().describe('Optional tree path prefix inside the wiki'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                path: z.string(),
+                entries: z.array(z.object({
+                    name: z.string(),
+                    path: z.string(),
+                    type: z.enum(['tree', 'blob']),
+                    size: z.number().optional(),
+                })),
+            },
+            handler: async (args) => {
+                const wiki = typeof args.wiki === 'string' ? args.wiki : '';
+                const path = typeof args.path === 'string' ? args.path : undefined;
+                const result = await getWikiTree(ctx, wiki, { path });
+                const structuredContent = {
+                    wiki_id: result.wiki.id,
+                    wiki_slug: result.wiki.slug,
+                    wiki_name: result.wiki.name,
+                    path: result.path,
+                    entries: result.entries,
+                };
+                return {
+                    text: jsonText(structuredContent),
+                    structuredContent,
+                };
+            },
+        },
+        {
+            name: 'wiki_status',
+            title: 'Inspect Wiki Workspace Status',
+            description: 'Inspect the current local mounted wiki workspace before proposing changes.',
+            readOnly: true,
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                mount_path: z.string(),
+                mode: z.enum(['read_only', 'read_write']),
+                default_ref: z.string(),
+                changed_paths: z.array(z.string()),
+                diff_files: z.array(z.object({
+                    path: z.string(),
+                    additions: z.number(),
+                    deletions: z.number(),
+                })),
+                dirty: z.boolean(),
+                source: z.literal('local_mount'),
+            },
+            handler: async (args) => {
+                const wiki = typeof args.wiki === 'string' ? args.wiki : '';
+                const result = await getWikiWorkspaceStatus(ctx, wiki);
+                return {
+                    text: jsonText(result),
+                    structuredContent: result,
+                };
+            },
+        },
+        {
+            name: 'wiki_diff',
+            title: 'Read Wiki Workspace Diff',
+            description: 'Read the current unified diff for a local mounted wiki workspace.',
+            readOnly: true,
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                mount_path: z.string(),
+                changed_paths: z.array(z.string()),
+                diff_files: z.array(z.object({
+                    path: z.string(),
+                    additions: z.number(),
+                    deletions: z.number(),
+                })),
+                patch: z.string(),
+                source: z.literal('local_mount'),
+            },
+            handler: async (args) => {
+                const wiki = typeof args.wiki === 'string' ? args.wiki : '';
+                const result = await getWikiWorkspaceDiff(ctx, wiki);
+                return {
+                    text: result.patch || jsonText(result),
+                    structuredContent: result,
+                };
+            },
+        },
+        {
+            name: 'wiki_blob',
+            title: 'Read Wiki File',
+            description: 'Read a file from a Parall wiki and return its text content.',
+            readOnly: true,
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                path: z.string().describe('File path inside the wiki'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                content: z.string(),
+                size: z.number(),
+            },
+            handler: async (args) => {
+                const wiki = typeof args.wiki === 'string' ? args.wiki : '';
+                const path = typeof args.path === 'string' ? args.path : '';
+                const result = await getWikiBlob(ctx, wiki, { path });
+                const structuredContent = {
+                    wiki_id: result.wiki.id,
+                    wiki_slug: result.wiki.slug,
+                    wiki_name: result.wiki.name,
+                    content: result.content,
+                    size: result.size,
+                };
+                return {
+                    text: result.content || jsonText(structuredContent),
+                    structuredContent,
+                };
+            },
+        },
+        {
+            name: 'wiki_search',
+            title: 'Search Wiki Markdown',
+            description: 'Search Markdown headings and section bodies inside a Parall wiki. Prefers local mounts when no ref is supplied and agent env is available; otherwise falls back to the Parall API.',
+            readOnly: true,
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                query: z.string().describe('Search query'),
+                ref: z.string().optional().describe('Optional git ref for API-backed search'),
+                path_prefix: z
+                    .string()
+                    .optional()
+                    .describe('Restrict search to a file or directory path prefix'),
+                limit: z
+                    .number()
+                    .int()
+                    .positive()
+                    .max(20)
+                    .optional()
+                    .describe('Maximum number of results; default 5'),
+                include_content: z
+                    .boolean()
+                    .optional()
+                    .describe('Include full matched section content in each result'),
+            },
+            outputSchema: {
+                results: z.array(z.object({
+                    wiki_id: z.string(),
+                    wiki_slug: z.string(),
+                    wiki_name: z.string(),
+                    node_id: z.string(),
+                    path: z.string(),
+                    title: z.string(),
+                    heading_path: z.array(z.string()).optional(),
+                    section_path: z.string(),
+                    level: z.number(),
+                    start_line: z.number(),
+                    end_line: z.number(),
+                    score: z.number(),
+                    snippet: z.string(),
+                    content: z.string().optional(),
+                    source: z.enum(['local_mount', 'api']),
+                })),
+            },
+            handler: async (args) => {
+                const wiki = typeof args.wiki === 'string' ? args.wiki : '';
+                const query = typeof args.query === 'string' ? args.query : '';
+                const ref = typeof args.ref === 'string' ? args.ref : undefined;
+                const pathPrefix = typeof args.path_prefix === 'string' ? args.path_prefix : undefined;
+                const limit = typeof args.limit === 'number' ? args.limit : undefined;
+                const includeContent = typeof args.include_content === 'boolean' ? args.include_content : undefined;
+                const results = await searchWiki(ctx, wiki, query, {
+                    ref,
+                    pathPrefix,
+                    limit,
+                    includeContent,
+                });
+                const structuredContent = { results };
+                return {
+                    text: jsonText(structuredContent),
+                    structuredContent,
+                };
+            },
+        },
+        {
+            name: 'wiki_query',
+            title: 'Query Wiki Structurally',
+            description: 'Run a tree-aware wiki query that first narrows candidate documents and then selects the best sections.',
+            readOnly: true,
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                query: z.string().describe('Natural-language query'),
+                ref: z.string().optional().describe('Optional git ref for API-backed queries'),
+                path_prefix: z
+                    .string()
+                    .optional()
+                    .describe('Restrict the query to a file or directory path prefix'),
+                limit: z
+                    .number()
+                    .int()
+                    .positive()
+                    .max(20)
+                    .optional()
+                    .describe('Maximum number of section results; default 5'),
+                include_content: z
+                    .boolean()
+                    .optional()
+                    .describe('Include full matched section content in each result'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                query: z.string(),
+                ref: z.string().optional(),
+                path_prefix: z.string().optional(),
+                generated_at: z.string(),
+                file_count: z.number(),
+                source: z.enum(['local_mount', 'api']),
+                documents: z.array(z.object({
+                    path: z.string(),
+                    title: z.string(),
+                    score: z.number(),
+                    matched_headings: z.array(z.string()),
+                    node_count: z.number(),
+                })),
+                sections: z.array(z.object({
+                    wiki_id: z.string(),
+                    wiki_slug: z.string(),
+                    wiki_name: z.string(),
+                    node_id: z.string(),
+                    path: z.string(),
+                    title: z.string(),
+                    heading_path: z.array(z.string()).optional(),
+                    section_path: z.string(),
+                    level: z.number(),
+                    start_line: z.number(),
+                    end_line: z.number(),
+                    score: z.number(),
+                    document_score: z.number(),
+                    snippet: z.string(),
+                    content: z.string().optional(),
+                    source: z.enum(['local_mount', 'api']),
+                    reasoning: z.array(z.string()),
+                })),
+            },
+            handler: async (args) => {
+                const wiki = typeof args.wiki === 'string' ? args.wiki : '';
+                const query = typeof args.query === 'string' ? args.query : '';
+                const ref = typeof args.ref === 'string' ? args.ref : undefined;
+                const pathPrefix = typeof args.path_prefix === 'string' ? args.path_prefix : undefined;
+                const limit = typeof args.limit === 'number' ? args.limit : undefined;
+                const includeContent = typeof args.include_content === 'boolean' ? args.include_content : undefined;
+                const result = await queryWiki(ctx, wiki, query, {
+                    ref,
+                    pathPrefix,
+                    limit,
+                    includeContent,
+                });
+                return {
+                    text: jsonText(result),
+                    structuredContent: result,
+                };
+            },
+        },
+        {
+            name: 'wiki_outline',
+            title: 'Read Wiki Outline',
+            description: 'Return the structural node outline for a Parall wiki or a path prefix within it.',
+            readOnly: true,
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                ref: z.string().optional().describe('Optional git ref for API-backed outline'),
+                path_prefix: z
+                    .string()
+                    .optional()
+                    .describe('Restrict outline to a file or directory path prefix'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                ref: z.string().optional(),
+                path_prefix: z.string().optional(),
+                generated_at: z.string(),
+                file_count: z.number(),
+                source: z.enum(['local_mount', 'api']),
+                nodes: z.array(z.object({
+                    wiki_id: z.string(),
+                    wiki_slug: z.string(),
+                    wiki_name: z.string(),
+                    node_id: z.string(),
+                    path: z.string(),
+                    title: z.string(),
+                    heading_path: z.array(z.string()).optional(),
+                    section_path: z.string(),
+                    level: z.number(),
+                    start_line: z.number(),
+                    end_line: z.number(),
+                })),
+            },
+            handler: async (args) => {
+                const wiki = typeof args.wiki === 'string' ? args.wiki : '';
+                const ref = typeof args.ref === 'string' ? args.ref : undefined;
+                const pathPrefix = typeof args.path_prefix === 'string' ? args.path_prefix : undefined;
+                const outline = await getWikiOutline(ctx, wiki, { ref, pathPrefix });
+                return {
+                    text: jsonText(outline),
+                    structuredContent: outline,
+                };
+            },
+        },
+        {
+            name: 'wiki_section',
+            title: 'Read Wiki Section',
+            description: 'Read a specific Markdown section from a Parall wiki by node ID. Node IDs come from `wiki_search` results.',
+            readOnly: true,
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                node_id: z.string().describe('Section node ID returned by wiki_search'),
+                ref: z
+                    .string()
+                    .optional()
+                    .describe('Optional git ref; when set, reads from the Parall API instead of a local mount'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                node_id: z.string(),
+                path: z.string(),
+                title: z.string(),
+                heading_path: z.array(z.string()).optional(),
+                section_path: z.string(),
+                level: z.number(),
+                start_line: z.number(),
+                end_line: z.number(),
+                content: z.string(),
+                source: z.enum(['local_mount', 'api']),
+            },
+            handler: async (args) => {
+                const wiki = typeof args.wiki === 'string' ? args.wiki : '';
+                const nodeId = typeof args.node_id === 'string' ? args.node_id : '';
+                const ref = typeof args.ref === 'string' ? args.ref : undefined;
+                const section = await getWikiSection(ctx, wiki, { nodeId, ref });
+                return {
+                    text: section.content || jsonText(section),
+                    structuredContent: section,
+                };
+            },
+        },
+        {
+            name: 'wiki_changeset_diff',
+            title: 'Read Wiki Changeset Diff',
+            description: 'Fetch the unified diff and changed file summary for a Parall wiki changeset.',
+            readOnly: true,
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                changeset_id: z.string().describe('Wiki changeset ID'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                changeset_id: z.string(),
+                diff: z.object({
+                    patch: z.string(),
+                    files: z.array(z.object({
+                        path: z.string(),
+                        additions: z.number(),
+                        deletions: z.number(),
+                    })),
+                }),
+            },
+            handler: async (args) => {
+                const wiki = typeof args.wiki === 'string' ? args.wiki : '';
+                const changesetId = typeof args.changeset_id === 'string' ? args.changeset_id : '';
+                const diff = await getWikiChangesetDiff(ctx, wiki, changesetId);
+                return {
+                    text: diff.diff.patch || jsonText(diff),
+                    structuredContent: diff,
+                };
+            },
+        },
+        {
+            name: 'wiki_propose',
+            title: 'Propose Wiki Changeset',
+            description: 'Create or update a wiki changeset from the current local mounted wiki workspace. Unprotected changesets may auto-merge immediately.',
+            readOnly: false,
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                title: z.string().min(1).describe('Changeset title'),
+                message: z.string().optional().describe('Changeset commit message (supports prll:// refs)'),
+                changeset_id: z.string().optional().describe('Existing changeset ID to update'),
+                source_chat_id: z
+                    .string()
+                    .optional()
+                    .describe('Optional source chat ID for approval workflow linkage'),
+                source_message_id: z
+                    .string()
+                    .optional()
+                    .describe('Optional source message ID for approval workflow linkage'),
+                source_run_id: z
+                    .string()
+                    .optional()
+                    .describe('Optional source run ID for approval workflow linkage'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                mount_path: z.string(),
+                changed_paths: z.array(z.string()),
+                status: z.string(),
+                auto_merged: z.boolean(),
+                requires_review: z.boolean(),
+                next_action: z.string(),
+                post_merge_sync: z
+                    .object({
+                    applied: z.number(),
+                    fastForwarded: z.number(),
+                    conflicts: z.array(z.unknown()),
+                    failed: z.array(z.unknown()),
+                })
+                    .nullable(),
+                post_merge_sync_error: z.string().nullable(),
+                diff_files: z.array(z.object({
+                    path: z.string(),
+                    additions: z.number(),
+                    deletions: z.number(),
+                })),
+                source: z.literal('local_mount'),
+                changeset: z
+                    .object({
+                    id: z.string(),
+                    wiki_id: z.string(),
+                    title: z.string(),
+                    status: z.string(),
+                    changed_paths: z.array(z.string()).optional(),
+                })
+                    .passthrough(),
+            },
+            handler: async (args) => {
+                const wiki = typeof args.wiki === 'string' ? args.wiki : '';
+                const title = typeof args.title === 'string' ? args.title : '';
+                const message = typeof args.message === 'string' ? args.message : undefined;
+                const changesetId = typeof args.changeset_id === 'string' ? args.changeset_id : undefined;
+                const sourceChatId = typeof args.source_chat_id === 'string' ? args.source_chat_id : undefined;
+                const sourceMessageId = typeof args.source_message_id === 'string' ? args.source_message_id : undefined;
+                const sourceRunId = typeof args.source_run_id === 'string' ? args.source_run_id : undefined;
+                const runtime = resolveRuntimeContext();
+                const result = await proposeWikiChangeset(ctx, wiki, {
+                    title,
+                    message,
+                    changesetId,
+                    sourceChatId: sourceChatId ?? runtime.chatId,
+                    sourceMessageId: sourceMessageId ?? runtime.triggerMessageId,
+                    sourceRunId: sourceRunId ?? runtime.sessionId,
+                });
+                return {
+                    text: jsonText(result),
+                    structuredContent: result,
+                };
+            },
+        },
+    ];
+    return tools.map(finalizeWikiTool);
+}

package/dist/lib/wiki.d.ts

@@ -1,4 +1,5 @@
 import { type ParallClient, type Wiki, type WikiChangeset, type WikiDiff, type WikiDiffFile, type WikiTreeEntry } from '@parall/sdk';
+export { type ParsedFrontMatter, parseFrontMatter } from './wiki-frontmatter.js';
 export type ParallContext = {
     client: ParallClient;
     orgId: string;
@@ -26,6 +27,9 @@ export type WikiNodeSection = {
     level: number;
     start_line: number;
     end_line: number;
+    type?: string;
+    description?: string;
+    tags?: string[];
 };
 export type WikiOutlineResult = {
     wiki_id: string;
@@ -143,10 +147,12 @@ export declare function getWikiTree(ctx: ParallContext, wikiRef?: string, option
 }>;
 export declare function getWikiBlob(ctx: ParallContext, wikiRef: string | undefined, options: {
     path: string;
+    remote?: boolean;
 }): Promise<{
     wiki: Wiki;
     content: string;
     size: number;
+    source: WikiContentSource;
 }>;
 export declare function getWikiOutline(ctx: ParallContext, wikiRef?: string, options?: {
     ref?: string;
@@ -166,14 +172,11 @@ export type AfcsStatusResult = {
     wiki_slug: string;
     wiki_name: string;
     mount_path: string;
-    mode: string;
     default_ref: string;
     /** Local workspace changes vs last-synced manifest. */
     local_changes: WikiDiffFile[];
     /** Pending changesets created by this agent. */
     changesets: AfcsChangesetSummary[];
-    /** Permission summary — null if the API is not yet available. */
-    permissions: AfcsPermissionSummary | null;
 };
 export type AfcsChangesetSummary = {
     id: string;
@@ -184,10 +187,6 @@ export type AfcsChangesetSummary = {
     created_at: string;
     updated_at: string;
 };
-export type AfcsPermissionSummary = {
-    readable_prefixes: string[];
-    writable_prefixes: string[];
-};
 export declare function getAfcsStatus(ctx: ParallContext, wikiRef?: string): Promise<AfcsStatusResult>;
 export type AfcsDiffResult = {
     wiki_id: string;
@@ -202,12 +201,15 @@ export declare function getAfcsDiff(ctx: ParallContext, wikiRef?: string): Promi
 export declare function proposeWikiChangeset(ctx: ParallContext, wikiRef: string | undefined, options: WikiProposeOptions): Promise<WikiProposeResult>;
 /**
  * Discard all local changes and restore files to the last synced state.
- * Reads the local manifest and restores all files from the server.
+ * Restores from the local baseline object store (network only as a
+ * SHA-verified fallback for pre-objects mounts), so the workspace lands
+ * exactly on the manifest baseline — `wiki status` reports clean afterwards.
  */
 export declare function resetWikiWorkspace(ctx: ParallContext, wikiRef?: string): Promise<{
     wiki_id: string;
     wiki_slug: string;
     files_restored: number;
+    unrestorable_paths: string[];
 }>;
 export type AfcsChangesetsResult = {
     wiki_id: string;
@@ -234,12 +236,14 @@ export type AfcsAccessRequestResult = {
 };
 export declare function requestWikiAccess(ctx: ParallContext, wikiRef: string | undefined, targetPath: string, reason?: string): Promise<AfcsAccessRequestResult>;
 export type AfcsLogEntry = {
-    type: 'file_version' | 'operation';
+    type: 'commit' | 'operation';
     id: string;
     path?: string;
     action: string;
-    actor_id: string;
-    version?: number;
+    /** Parall actor ID — operation entries only (git commits carry no Parall identity). */
+    actor_id?: string;
+    /** Git author display name — commit entries only. */
+    author_name?: string;
     created_at: string;
 };
 export type AfcsLogResult = {
@@ -249,6 +253,10 @@ export type AfcsLogResult = {
     path?: string;
     entries: AfcsLogEntry[];
 };
+/**
+ * Wiki history. Without a path: recent wiki operations (audit log). With a
+ * path: that file's commit history from the default branch.
+ */
 export declare function getWikiLog(ctx: ParallContext, wikiRef?: string, filePath?: string): Promise<AfcsLogResult>;
 export type SyncResult = {
     /** True iff every wiki's per-path action ran without failure. Conflicts do
@@ -267,11 +275,13 @@ export type SyncResult = {
     }[];
 };
 /**
- * List accessible wikis for this org, sync each via REST
- * (manifest comparison + bulk download), and remove stale directories.
+ * Sync wiki workspaces via REST (manifest comparison + bulk download).
+ * Without `wikiRef`: every accessible wiki is synced and stale mount
+ * directories are pruned. With `wikiRef`: only that wiki is synced and
+ * pruning is skipped — other wikis' workspaces must survive a scoped sync.
  * Mount path is determined client-side: {mountRoot}/{slug}/
  */
-export declare function syncAllMounts(ctx: ParallContext): Promise<SyncResult>;
+export declare function syncAllMounts(ctx: ParallContext, wikiRef?: string): Promise<SyncResult>;
 /**
  * Run {@link syncAllMounts} in a loop, sleeping `intervalSec` between
  * iterations. Returns a `stop` callback to break the loop.
@@ -370,5 +380,13 @@ export declare function syncSingleWiki(ctx: ParallContext, wiki: import('@parall
  */
 export declare function writeConflictMarker(mountRoot: string, sourcePath: string, suffix: string, content: Buffer): Promise<string>;
 export declare function computeGitBlobSHA(content: Buffer): string;
-export {};
+/**
+ * Mirror of the server's text classifier (filetype.IsText): content-type
+ * magic sniff, valid UTF-8, and no NUL bytes — kept aligned so content the
+ * CLI accepts cannot bounce off the server's 422 USE_UPLOAD later. The
+ * shared fixture table (test/testdata/text-classifier-cases.json) is
+ * verified by both this implementation's tests and the Go package's tests.
+ */
+export declare function isWikiTextContent(content: Buffer): boolean;
+export declare function detectFrontMatterEnd(lines: string[]): number;
 //# sourceMappingURL=wiki.d.ts.map