@parall/cli 1.12.0

package/dist/commands/wiki.js

@@ -0,0 +1,644 @@
+import { resolveCredentials, resolveRuntimeContext } from '../lib/client.js';
+import { printError, printJson } from '../lib/output.js';
+import { getAfcsDiff, getAfcsStatus, getWikiBlob, getWikiChangesetDetail, getWikiChangesetDiff, getWikiLog, getWikiOutline, getWikiSection, getWikiTree, listWikiChangesets, queryWiki, requestWikiAccess, resetWikiWorkspace, listWikis, proposeWikiChangeset, searchWiki, syncAllMounts, watchMounts, } from '../lib/wiki.js';
+export function registerWikiCommands(program) {
+    const wiki = program.command('wiki').description('Parall Wiki — read, edit, and propose changes');
+    // ---- Core workflow ----
+    wiki
+        .command('sync')
+        .description('Sync wiki files to local workspace. First run downloads all files; subsequent runs pull updates.')
+        .argument('[wiki]', 'Wiki ID or slug (omit to sync all wikis)')
+        .action(async (_wiki) => {
+        try {
+            const ctx = resolveCredentials();
+            const result = await syncAllMounts(ctx);
+            for (const entry of result.synced) {
+                process.stderr.write(`wiki ${entry.slug} synced → ${entry.path}\n`);
+            }
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+            process.exit(1);
+        }
+    });
+    wiki
+        .command('status')
+        .description('Show local changes, pending changesets, and permission summary.')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .action(async (wikiRef) => {
+        try {
+            const ctx = resolveCredentials();
+            const result = await getAfcsStatus(ctx, wikiRef);
+            process.stderr.write(`Wiki: ${result.wiki_name} (${result.wiki_slug})\n`);
+            process.stderr.write(`Mount: ${result.mount_path}\n`);
+            process.stderr.write(`Mode: ${result.mode}\n\n`);
+            if (result.local_changes.length === 0) {
+                process.stderr.write('Local changes: none\n');
+            }
+            else {
+                process.stderr.write('Local changes:\n');
+                for (const file of result.local_changes) {
+                    const s = file.additions > 0 && file.deletions > 0 ? 'M'
+                        : file.additions > 0 ? 'A' : 'D';
+                    process.stderr.write(`  ${s} ${file.path} (+${file.additions} -${file.deletions})\n`);
+                }
+            }
+            process.stderr.write('\n');
+            if (result.changesets.length === 0) {
+                process.stderr.write('Changesets: none\n');
+            }
+            else {
+                process.stderr.write('Changesets:\n');
+                for (const cs of result.changesets) {
+                    process.stderr.write(`  ${cs.id}  ${cs.status.toUpperCase()}  "${cs.title}"\n`);
+                    if (cs.feedback) {
+                        process.stderr.write(`    Feedback: ${cs.feedback}\n`);
+                    }
+                }
+            }
+            if (result.permissions) {
+                process.stderr.write('\nPermissions:\n');
+                process.stderr.write(`  Read:  ${result.permissions.readable_prefixes.join(', ')}\n`);
+                process.stderr.write(`  Write: ${result.permissions.writable_prefixes.join(', ') || 'none'}\n`);
+            }
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    wiki
+        .command('diff')
+        .description('Show local workspace diff against last synced state.')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .option('--raw', 'Print only the unified diff patch')
+        .action(async (wikiRef, options) => {
+        try {
+            const ctx = resolveCredentials();
+            const result = await getAfcsDiff(ctx, wikiRef);
+            if (options?.raw) {
+                process.stdout.write(result.patch);
+                if (result.patch && !result.patch.endsWith('\n'))
+                    process.stdout.write('\n');
+                return;
+            }
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    wiki
+        .command('reset')
+        .description('Discard all local changes and restore files to the last synced state (re-downloads from server).')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .action(async (wikiRef) => {
+        try {
+            const ctx = resolveCredentials();
+            const result = await resetWikiWorkspace(ctx, wikiRef);
+            process.stderr.write(`Reset ${result.files_restored} file(s) to last synced state.\n`);
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    wiki
+        .command('request-access')
+        .description('Request read/write access to a locked wiki path. Creates an approval card for a maintainer.')
+        .argument('<path>', 'Path to request access for (e.g. docs/ops/)')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .option('--reason <reason>', 'Reason for the access request')
+        .action(async (targetPath, wikiRef, options) => {
+        try {
+            const ctx = resolveCredentials();
+            const result = await requestWikiAccess(ctx, wikiRef, targetPath, options.reason);
+            process.stderr.write(`${result.message}\n`);
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    wiki
+        .command('log')
+        .description('Show version history. With a path: per-file history. Without: recent operations.')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .argument('[path]', 'File path for per-file history')
+        .action(async (wikiRef, filePath) => {
+        try {
+            const ctx = resolveCredentials();
+            const result = await getWikiLog(ctx, wikiRef, filePath);
+            if (result.entries.length === 0) {
+                process.stderr.write('No history entries found.\n');
+            }
+            else {
+                for (const entry of result.entries) {
+                    const pathSuffix = entry.path ? ` ${entry.path}` : '';
+                    process.stderr.write(`${entry.id.slice(0, 8)}  ${entry.created_at}  ${entry.action}${pathSuffix}\n`);
+                }
+            }
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    // ---- Changeset subcommands ----
+    const changeset = wiki.command('changeset').description('Manage wiki changesets (proposals)');
+    changeset
+        .command('create')
+        .description('Create a new changeset from local workspace changes.')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .option('--title <title>', 'Changeset title (required for new changesets)')
+        .option('--message <message>', 'Changeset commit message (supports prll:// refs)')
+        .option('--update <changesetId>', 'Re-propose an existing rejected/conflict changeset (title is inherited)')
+        .option('--chat-id <chatId>', 'Source chat ID for approval workflow')
+        .option('--message-id <messageId>', 'Source message ID for approval workflow')
+        .option('--session-id <sessionId>', 'Source agent session ID for approval workflow')
+        .action(async (wikiRef, options) => {
+        try {
+            if (!options.update && !options.title) {
+                process.stderr.write('Error: --title is required when creating a new changeset.\n');
+                process.stderr.write('  Use --update <id> to re-propose a rejected/conflict changeset (title inherited).\n');
+                process.exit(1);
+            }
+            const ctx = resolveCredentials();
+            const rtx = resolveRuntimeContext();
+            // Inherit title from existing changeset when re-proposing via --update
+            const inheritedTitle = options.update && !options.title
+                ? (await getWikiChangesetDetail(ctx, wikiRef, options.update)).changeset.title
+                : undefined;
+            const result = await proposeWikiChangeset(ctx, wikiRef, {
+                title: options.title ?? inheritedTitle ?? '',
+                message: options.message,
+                changesetId: options.update,
+                sourceChatId: options.chatId ?? rtx.chatId,
+                sourceMessageId: options.messageId ?? rtx.triggerMessageId,
+                sourceRunId: options.sessionId ?? rtx.sessionId,
+            });
+            const verb = options.update ? 'Re-proposed' : 'Created';
+            process.stderr.write(`${verb} changeset ${result.changeset.id}\n`);
+            process.stderr.write(`Changed files: ${result.changed_paths.join(', ')}\n`);
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    changeset
+        .command('list')
+        .description('List all changesets. Shows ID, status, title, and date.')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .action(async (wikiRef) => {
+        try {
+            const ctx = resolveCredentials();
+            const result = await listWikiChangesets(ctx, wikiRef);
+            if (result.changesets.length === 0) {
+                process.stderr.write('No changesets found.\n');
+            }
+            else {
+                for (const cs of result.changesets) {
+                    process.stderr.write(`${cs.id}  ${cs.status.toUpperCase().padEnd(10)}  "${cs.title}"  ${cs.created_at}\n`);
+                }
+            }
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    changeset
+        .command('show')
+        .description('Show changeset detail including status, changed files, and feedback.')
+        .argument('<changesetId>', 'Changeset ID')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .action(async (changesetId, wikiRef) => {
+        try {
+            const ctx = resolveCredentials();
+            const result = await getWikiChangesetDetail(ctx, wikiRef, changesetId);
+            const cs = result.changeset;
+            process.stderr.write(`Changeset: ${cs.id}\n`);
+            process.stderr.write(`Status: ${cs.status.toUpperCase()}\n`);
+            process.stderr.write(`Title: ${cs.title}\n`);
+            if (cs.message)
+                process.stderr.write(`Message: ${cs.message}\n`);
+            process.stderr.write(`Created: ${cs.created_at}\n`);
+            process.stderr.write(`Updated: ${cs.updated_at}\n`);
+            if (cs.changed_paths.length > 0) {
+                process.stderr.write('Changed files:\n');
+                for (const p of cs.changed_paths)
+                    process.stderr.write(`  ${p}\n`);
+            }
+            if (cs.last_error) {
+                process.stderr.write(`\nFeedback: ${cs.last_error}\n`);
+                if (cs.status === 'rejected') {
+                    process.stderr.write('\nTo fix: edit the file(s), then run:\n'
+                        + `  parall wiki changeset create --update ${cs.id}\n`);
+                }
+                else if (cs.status === 'conflict') {
+                    process.stderr.write('\nTo resolve: run `parall wiki sync`, fix conflicts, then:\n'
+                        + `  parall wiki changeset create --update ${cs.id}\n`);
+                }
+            }
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    changeset
+        .command('diff')
+        .description('Show the diff of a changeset.')
+        .argument('<changesetId>', 'Changeset ID')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .option('--raw', 'Print only the unified diff patch')
+        .action(async (changesetId, wikiRef, options) => {
+        try {
+            const ctx = resolveCredentials();
+            const result = await getWikiChangesetDiff(ctx, wikiRef, changesetId);
+            if (options?.raw) {
+                process.stdout.write(result.diff.patch);
+                if (result.diff.patch && !result.diff.patch.endsWith('\n'))
+                    process.stdout.write('\n');
+                return;
+            }
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    changeset
+        .command('merge')
+        .description('Merge a changeset into the wiki default branch')
+        .argument('<changesetId>', 'Changeset ID')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .action(async (changesetId, wikiRef) => {
+        try {
+            const ctx = resolveCredentials();
+            const { resolveWikiRefOrDefault } = await import('../lib/wiki.js');
+            const wiki = await resolveWikiRefOrDefault(ctx, wikiRef);
+            const result = await ctx.client.mergeWikiChangeset(ctx.orgId, wiki.id, changesetId);
+            process.stderr.write(`Merged changeset ${result.id} — "${result.title}"\n`);
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    changeset
+        .command('close')
+        .description('Close a changeset without merging')
+        .argument('<changesetId>', 'Changeset ID')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .action(async (changesetId, wikiRef) => {
+        try {
+            const ctx = resolveCredentials();
+            const { resolveWikiRefOrDefault } = await import('../lib/wiki.js');
+            const wiki = await resolveWikiRefOrDefault(ctx, wikiRef);
+            const result = await ctx.client.closeWikiChangeset(ctx.orgId, wiki.id, changesetId);
+            process.stderr.write(`Closed changeset ${result.id}\n`);
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    // ---- Content browsing (search, query, outline, section) ----
+    wiki
+        .command('search')
+        .description('Search wiki content by keyword')
+        .argument('<query>', 'Search query')
+        .argument('[wiki]', 'Wiki ID or slug')
+        .option('--path <path>', 'Restrict to a path prefix')
+        .option('--limit <n>', 'Max results (default 5)')
+        .option('--include-content', 'Include full section content in results')
+        .action(async (query, wikiRef, options) => {
+        try {
+            const ctx = resolveCredentials();
+            const limit = options.limit ? parseIntStrict(options.limit) : undefined;
+            const results = await searchWiki(ctx, wikiRef, query, {
+                pathPrefix: options.path,
+                limit,
+                includeContent: options.includeContent,
+            });
+            if (results.length === 0) {
+                process.stderr.write('No results found.\n');
+            }
+            else {
+                for (const r of results) {
+                    process.stderr.write(`[${r.score.toFixed(2)}] ${r.section_path}\n`);
+                    process.stderr.write(`       ${r.snippet}\n\n`);
+                }
+            }
+            printJson(results);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    wiki
+        .command('query')
+        .description('Tree-aware structured query over wiki sections')
+        .argument('<query>', 'Natural-language query')
+        .argument('[wiki]', 'Wiki ID or slug')
+        .option('--path <path>', 'Restrict to a path prefix')
+        .option('--limit <n>', 'Max results (default 5)')
+        .option('--include-content', 'Include full section content in results')
+        .action(async (query, wikiRef, options) => {
+        try {
+            const ctx = resolveCredentials();
+            const limit = options.limit ? parseIntStrict(options.limit) : undefined;
+            const result = await queryWiki(ctx, wikiRef, query, {
+                pathPrefix: options.path,
+                limit,
+                includeContent: options.includeContent,
+            });
+            if (result.documents.length > 0) {
+                process.stderr.write('Documents:\n');
+                for (const doc of result.documents) {
+                    process.stderr.write(`  [${doc.score.toFixed(2)}] ${doc.path} — ${doc.title} (${doc.node_count} sections)\n`);
+                }
+                process.stderr.write('\nSections:\n');
+                for (const s of result.sections) {
+                    process.stderr.write(`  [${s.score.toFixed(2)}] ${s.section_path}\n`);
+                    process.stderr.write(`         ${s.snippet}\n\n`);
+                }
+            }
+            else {
+                process.stderr.write('No results found.\n');
+            }
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    wiki
+        .command('outline')
+        .description('Show structural outline of wiki markdown sections')
+        .argument('[wiki]', 'Wiki ID or slug')
+        .option('--path <path>', 'Restrict to a path prefix')
+        .action(async (wikiRef, options) => {
+        try {
+            const ctx = resolveCredentials();
+            const result = await getWikiOutline(ctx, wikiRef, { pathPrefix: options.path });
+            process.stderr.write(`Wiki: ${result.wiki_name} (${result.wiki_slug})  |  ${result.file_count} files  |  source: ${result.source}\n\n`);
+            let currentPath = '';
+            for (const node of result.nodes) {
+                if (node.path !== currentPath) {
+                    currentPath = node.path;
+                    process.stderr.write(`${currentPath}\n`);
+                }
+                const indent = '  '.repeat(Math.max(node.level, 1));
+                process.stderr.write(`${indent}${node.title}  (${node.node_id})\n`);
+            }
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    wiki
+        .command('tree')
+        .description('List files and directories in a wiki')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .option('--path <path>', 'Restrict to a subdirectory')
+        .action(async (wikiRef, options) => {
+        try {
+            const ctx = resolveCredentials();
+            printJson(await getWikiTree(ctx, wikiRef, { path: options?.path }));
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    wiki
+        .command('cat')
+        .description('Read a wiki page by file path (raw markdown content)')
+        .argument('<path>', 'File path (e.g. docs/auth.md)')
+        .argument('[wiki]', 'Wiki ID or slug')
+        .action(async (filePath, wikiRef) => {
+        try {
+            const ctx = resolveCredentials();
+            const result = await getWikiBlob(ctx, wikiRef, { path: filePath });
+            process.stderr.write(`${filePath}  (${result.size} bytes)\n\n`);
+            process.stdout.write(result.content);
+            if (result.content && !result.content.endsWith('\n'))
+                process.stdout.write('\n');
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    wiki
+        .command('section')
+        .description('Fetch a wiki section by node ID')
+        .argument('<nodeId>', 'Section node ID (from search/outline results)')
+        .argument('[wiki]', 'Wiki ID or slug')
+        .action(async (nodeId, wikiRef) => {
+        try {
+            const ctx = resolveCredentials();
+            const result = await getWikiSection(ctx, wikiRef, { nodeId });
+            process.stderr.write(`${result.section_path}  (L${result.start_line}–${result.end_line})\n\n`);
+            process.stdout.write(result.content);
+            if (result.content && !result.content.endsWith('\n'))
+                process.stdout.write('\n');
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    wiki
+        .command('locate')
+        .description('Resolve a heading path to a stable section ID (e.g. docs/auth.md#OAuth → section details)')
+        .argument('<anchor>', 'File path with heading anchor (e.g. docs/auth.md#OAuth or docs/auth.md#Auth#OAuth)')
+        .argument('[wiki]', 'Wiki ID or slug')
+        .action(async (anchor, wikiRef) => {
+        try {
+            const ctx = resolveCredentials();
+            const hashIdx = anchor.indexOf('#');
+            if (hashIdx < 0) {
+                process.stderr.write('Error: anchor must contain # (e.g. docs/auth.md#OAuth)\n');
+                process.exit(1);
+            }
+            const filePath = anchor.slice(0, hashIdx);
+            const fragment = anchor.slice(hashIdx + 1);
+            const fragParts = fragment.split('#').map(s => s.toLowerCase());
+            const { resolveWikiRefOrDefault, getWikiOutline } = await import('../lib/wiki.js');
+            const wiki = await resolveWikiRefOrDefault(ctx, wikiRef);
+            const outline = await getWikiOutline(ctx, wiki.slug, { pathPrefix: filePath });
+            // Find section whose heading_path ends with the fragment parts
+            const match = outline.nodes.find(node => {
+                if (node.path !== filePath || !node.heading_path || node.heading_path.length < fragParts.length)
+                    return false;
+                const offset = node.heading_path.length - fragParts.length;
+                return fragParts.every((part, i) => node.heading_path[offset + i].toLowerCase() === part);
+            });
+            if (!match) {
+                process.stderr.write(`Section not found: ${anchor}\n`);
+                process.stderr.write(`Available sections in ${filePath}:\n`);
+                for (const node of outline.nodes.filter(n => n.path === filePath && n.level > 0)) {
+                    process.stderr.write(`  ${node.path}#${(node.heading_path ?? []).join('#')}  (${node.node_id})\n`);
+                }
+                process.exit(1);
+            }
+            const stableId = `${match.path}#${(match.heading_path ?? [match.title]).join('#')}`;
+            const prllUri = `prll://${wiki.id}/${match.path}#${(match.heading_path ?? [match.title]).join('#')}`;
+            process.stderr.write(`Resolved: ${anchor}\n`);
+            process.stderr.write(`  section_path: ${match.section_path}\n`);
+            process.stderr.write(`  node_id:      ${match.node_id}\n`);
+            process.stderr.write(`  stable_id:    ${stableId}\n`);
+            process.stderr.write(`  prll_uri:      ${prllUri}\n`);
+            process.stderr.write(`  lines:        L${match.start_line}–${match.end_line}\n`);
+            printJson({ ...match, stable_id: stableId, prll_uri: prllUri });
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    wiki
+        .command('pages')
+        .description('List all wiki pages with metadata (lightweight page index)')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .action(async (wikiRef) => {
+        try {
+            const ctx = resolveCredentials();
+            const wiki = await (await import('../lib/wiki.js')).resolveWikiRefOrDefault(ctx, wikiRef);
+            const result = await ctx.client.getWikiPageIndex(ctx.orgId, wiki.id);
+            process.stderr.write(`Wiki: ${result.wiki_name} (${result.wiki_slug})  |  ${result.page_count} pages\n\n`);
+            for (const page of result.pages) {
+                const headings = page.top_headings.length > 0 ? ` — ${page.top_headings.join(', ')}` : '';
+                process.stderr.write(`  ${page.path}  "${page.title}"  (${page.section_count} sections, ${page.size_bytes}B)${headings}\n`);
+            }
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    // ---- References (lat.md-style knowledge graph) ----
+    const wikiRefs = wiki.command('refs').description('Wiki reference graph — extract and validate prll:// links');
+    wikiRefs
+        .command('list')
+        .description('List all prll:// references found in wiki markdown files')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .action(async (wikiRef) => {
+        try {
+            const ctx = resolveCredentials();
+            const w = await (await import('../lib/wiki.js')).resolveWikiRefOrDefault(ctx, wikiRef);
+            const result = await ctx.client.getWikiRefs(ctx.orgId, w.id);
+            process.stderr.write(`Wiki: ${result.wiki_name} (${result.wiki_slug})  |  ${result.total} refs\n\n`);
+            for (const r of result.refs) {
+                const ctx_text = r.context ? ` "${r.context}"` : '';
+                process.stderr.write(`  ${r.source_path}:${r.line}  →  ${r.uri}${ctx_text}\n`);
+            }
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    wikiRefs
+        .command('backlinks')
+        .description('Show what references a specific wiki page or section (who links here?)')
+        .argument('<anchor>', 'Wiki path or prll:// URI (e.g. docs/auth.md or docs/auth.md#OAuth)')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .option('--limit <n>', 'Max results (default 20)')
+        .action(async (anchor, wikiRef, options) => {
+        try {
+            const ctx = resolveCredentials();
+            const limit = options.limit ? parseIntStrict(options.limit) : 20;
+            // Build prll:// URI from the anchor if it's not already one
+            let uri = anchor;
+            if (!anchor.startsWith('prll://')) {
+                const { resolveWikiRefOrDefault } = await import('../lib/wiki.js');
+                const wiki = await resolveWikiRefOrDefault(ctx, wikiRef);
+                const hashIdx = anchor.indexOf('#');
+                const filePath = hashIdx >= 0 ? anchor.slice(0, hashIdx) : anchor;
+                const fragment = hashIdx >= 0 ? anchor.slice(hashIdx + 1) : '';
+                uri = `prll://${wiki.id}/${filePath}${fragment ? '#' + fragment : ''}`;
+            }
+            const result = await ctx.client.getBacklinks(ctx.orgId, { uri, limit });
+            if (result.backlinks.length === 0) {
+                process.stderr.write(`No backlinks found for ${uri}\n`);
+            }
+            else {
+                process.stderr.write(`Backlinks for ${uri}:\n\n`);
+                for (const bl of result.backlinks) {
+                    const who = bl.sender_name ?? bl.author_name ?? bl.source_type;
+                    const snippet = bl.snippet ? ` — ${bl.snippet}` : '';
+                    const ctx_text = bl.context ? ` [${bl.context}]` : '';
+                    process.stderr.write(`  ${bl.source_type}/${bl.source_id}  ${who}${ctx_text}${snippet}\n`);
+                }
+            }
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    wikiRefs
+        .command('check')
+        .description('Validate prll:// wiki refs that target files/headings inside the same wiki')
+        .argument('[wiki]', 'Wiki ID or slug (auto-resolves if org has one wiki)')
+        .action(async (wikiRef) => {
+        try {
+            const ctx = resolveCredentials();
+            const w = await (await import('../lib/wiki.js')).resolveWikiRefOrDefault(ctx, wikiRef);
+            const result = await ctx.client.checkWikiRefs(ctx.orgId, w.id);
+            if (result.total === 0) {
+                process.stderr.write(`Wiki: ${result.wiki_name} — all references valid ✓\n`);
+            }
+            else {
+                process.stderr.write(`Wiki: ${result.wiki_name} — ${result.total} broken ref(s) found:\n\n`);
+                for (const b of result.broken) {
+                    process.stderr.write(`  ${b.source_path}:${b.line}  →  ${b.uri}\n`);
+                    process.stderr.write(`    reason: ${b.reason}\n\n`);
+                }
+            }
+            printJson(result);
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    // ---- Utility (not for direct agent use) ----
+    wiki
+        .command('list')
+        .description('List organization wikis')
+        .action(async () => {
+        try {
+            const ctx = resolveCredentials();
+            printJson(await listWikis(ctx));
+        }
+        catch (error) {
+            printError(error);
+        }
+    });
+    wiki
+        .command('watch')
+        .description('Periodically sync wiki files (used by runtime, not for direct use)')
+        .option('--interval-sec <n>', 'Refresh interval in seconds', '60')
+        .action(async (options) => {
+        try {
+            const intervalSec = parseIntStrict(options.intervalSec);
+            const ctx = resolveCredentials();
+            process.stderr.write(`watching wiki mounts every ${intervalSec}s\n`);
+            watchMounts(ctx, intervalSec);
+        }
+        catch (error) {
+            printError(error);
+            process.exit(1);
+        }
+    });
+}
+function parseIntStrict(value) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`invalid positive integer: ${value}`);
+    }
+    return parsed;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { Command } from 'commander';
+import { registerAgentCommands } from './commands/agents.js';
+import { registerChatCommands } from './commands/chats.js';
+import { registerDMCommands } from './commands/dm.js';
+import { registerMessageCommands } from './commands/messages.js';
+import { registerTaskCommands } from './commands/tasks.js';
+import { registerProjectCommands } from './commands/projects.js';
+import { registerUserCommands } from './commands/users.js';
+import { registerWikiCommands } from './commands/wiki.js';
+import { registerMcpCommands } from './commands/mcp.js';
+import { registerRefCommands } from './commands/refs.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+const program = new Command();
+program
+    .name('parall')
+    .description('CLI client for Parall — universal agent & human access to Parall API')
+    .version(pkg.version);
+registerAgentCommands(program);
+registerChatCommands(program);
+registerDMCommands(program);
+registerMessageCommands(program);
+registerTaskCommands(program);
+registerProjectCommands(program);
+registerUserCommands(program);
+registerWikiCommands(program);
+registerMcpCommands(program);
+registerRefCommands(program);
+program.parse();