edgar-cli 0.1.4 → 0.2.2

package/dist/cli.js

@@ -1,332 +0,0 @@
-#!/usr/bin/env node
-import { realpathSync } from 'node:fs';
-import { Command, CommanderError } from 'commander';
-import { fileURLToPath } from 'node:url';
-import { runFactsGet } from './commands/facts.js';
-import { runFilingsGet, runFilingsList } from './commands/filings.js';
-import { parseResearchProfile, runResearchAsk, runResearchAskById, runResearchSync } from './commands/research.js';
-import { runResolve } from './commands/resolve.js';
-import { buildRuntimeOptions, parseDateString, parseNonNegativeInt, parsePositiveInt, requireUserAgent } from './core/config.js';
-import { failureEnvelope, successEnvelope } from './core/envelope.js';
-import { CLIError, ErrorCode, EXIT_CODE_MAP, isCLIError } from './core/errors.js';
-import { shapeData } from './core/output-shape.js';
-import { SecClient } from './sec/client.js';
-class CLIAbortError extends Error {
-    exitCode;
-    constructor(exitCode) {
-        super(`CLI exited with code ${exitCode}`);
-        this.exitCode = exitCode;
-        this.name = 'CLIAbortError';
-    }
-}
-function defaultIo() {
-    return {
-        stdout: (message) => process.stdout.write(message),
-        stderr: (message) => process.stderr.write(message),
-        env: process.env
-    };
-}
-function humanPrint(io, data) {
-    io.stdout(`${JSON.stringify(data, null, 2)}\n`);
-}
-function emitSuccess(params) {
-    const { context, io, command, result } = params;
-    if (context.runtime.humanMode) {
-        humanPrint(io, result.data);
-        return;
-    }
-    const shaped = shapeData({
-        data: result.data,
-        fields: context.runtime.fields,
-        limit: context.runtime.limit
-    });
-    const metaUpdates = {
-        ...(result.metaUpdates ?? {}),
-        ...shaped.metaUpdates
-    };
-    const envelope = successEnvelope({
-        command,
-        data: shaped.data,
-        view: context.runtime.view,
-        metaUpdates
-    });
-    io.stdout(`${JSON.stringify(envelope)}\n`);
-}
-function emitError(params) {
-    const { command, err, runtimeView, humanMode, io } = params;
-    if (humanMode) {
-        io.stderr(`${err.code} ${err.message}\n`);
-        return err.exitCode;
-    }
-    const envelope = failureEnvelope({
-        command,
-        code: err.code,
-        message: err.message,
-        retriable: err.retriable,
-        view: runtimeView
-    });
-    io.stdout(`${JSON.stringify(envelope)}\n`);
-    return err.exitCode;
-}
-function toCliError(err) {
-    if (isCLIError(err)) {
-        return err;
-    }
-    return new CLIError(ErrorCode.INTERNAL_ERROR, err.message || 'Unexpected error');
-}
-async function executeCommand(command, commandObj, io, handler, options) {
-    const globalOptions = commandObj.optsWithGlobals();
-    const runtime = buildRuntimeOptions({
-        json: globalOptions.json,
-        human: globalOptions.human,
-        view: globalOptions.view,
-        fields: globalOptions.fields,
-        limit: globalOptions.limit,
-        verbose: globalOptions.verbose,
-        userAgent: globalOptions.userAgent
-    }, io.env);
-    try {
-        const requiresSecIdentity = options?.requiresSecIdentity ?? true;
-        const userAgent = requiresSecIdentity
-            ? requireUserAgent(runtime.userAgent)
-            : runtime.userAgent ?? 'edgar-cli local research';
-        const secClient = new SecClient({
-            userAgent,
-            verbose: runtime.verbose,
-            logger: (message) => io.stderr(`[debug] ${message}\n`)
-        });
-        const context = {
-            runtime,
-            secClient
-        };
-        const result = await handler(context);
-        emitSuccess({ command, result, context, io });
-    }
-    catch (error) {
-        const cliError = toCliError(error);
-        const exitCode = emitError({
-            command,
-            err: cliError,
-            runtimeView: runtime.view,
-            humanMode: runtime.humanMode,
-            io
-        });
-        throw new CLIAbortError(exitCode);
-    }
-}
-export function buildProgram(io) {
-    const program = new Command();
-    program
-        .name('edgar')
-        .description('Agent-friendly SEC EDGAR CLI')
-        .option('--json', 'Emit JSON envelope output (default)')
-        .option('--human', 'Emit human-readable output')
-        .option('--view <view>', 'Output view mode (summary|full)', 'summary')
-        .option('--fields <fields>', 'Select specific response fields in JSON mode')
-        .option('--limit <n>', 'Limit output rows in JSON mode')
-        .option('--verbose', 'Enable verbose debug logs')
-        .option('--user-agent <value>', 'SEC identity (required for network commands), e.g. "Name email@domain.com"')
-        .showHelpAfterError(true)
-        .exitOverride()
-        .addHelpText('after', '\nSEC identity is required for network commands.\nSet --user-agent or EDGAR_USER_AGENT.')
-        .configureOutput({
-        writeOut: (message) => io.stdout(message),
-        writeErr: (message) => io.stderr(message)
-    });
-    program
-        .command('resolve')
-        .description('Resolve ticker/CIK to canonical SEC identity fields')
-        .argument('<id>', 'Ticker (AAPL) or CIK (320193 / 0000320193)')
-        .action(async function actionResolve(id) {
-        await executeCommand('resolve', this, io, async (context) => runResolve(id, context));
-    });
-    const filings = program.command('filings').description('Query filing metadata and filing documents');
-    filings
-        .command('list')
-        .requiredOption('--id <id>', 'Ticker or CIK')
-        .option('--form <form>', 'SEC form type, e.g. 10-K')
-        .option('--from <yyyy-mm-dd>', 'Lower filing-date bound')
-        .option('--to <yyyy-mm-dd>', 'Upper filing-date bound')
-        .option('--query-limit <n>', 'Limit rows before envelope shaping')
-        .option('--offset <n>', 'Offset rows before query-limit slicing', '0')
-        .action(async function actionFilingsList(options) {
-        const from = options.from ? parseDateString(options.from, '--from') : undefined;
-        const to = options.to ? parseDateString(options.to, '--to') : undefined;
-        const queryLimit = options.queryLimit === undefined
-            ? undefined
-            : parsePositiveInt(options.queryLimit, '--query-limit');
-        const offset = parseNonNegativeInt(options.offset, '--offset');
-        await executeCommand('filings list', this, io, async (context) => runFilingsList({
-            id: options.id,
-            form: options.form,
-            from,
-            to,
-            queryLimit,
-            offset
-        }, context));
-    });
-    filings
-        .command('get')
-        .requiredOption('--id <id>', 'Ticker or CIK')
-        .requiredOption('--accession <accession>', 'Accession number: XXXXXXXXXX-XX-XXXXXX')
-        .option('--format <format>', 'url|html|text|markdown', 'url')
-        .action(async function actionFilingsGet(options) {
-        const format = options.format;
-        if (!['url', 'html', 'text', 'markdown'].includes(format)) {
-            throw new CLIAbortError(emitError({
-                command: 'filings get',
-                err: new CLIError(ErrorCode.VALIDATION_ERROR, '--format must be one of url|html|text|markdown'),
-                runtimeView: 'summary',
-                humanMode: false,
-                io
-            }));
-        }
-        await executeCommand('filings get', this, io, async (context) => runFilingsGet({
-            id: options.id,
-            accession: options.accession,
-            format: format
-        }, context));
-    });
-    const facts = program.command('facts').description('Query SEC company facts (XBRL)');
-    facts
-        .command('get')
-        .requiredOption('--id <id>', 'Ticker or CIK')
-        .option('--taxonomy <taxonomy>', 'us-gaap|dei')
-        .option('--concept <concept>', 'Concept name, e.g. Revenues')
-        .option('--unit <unit>', 'Unit key, e.g. USD')
-        .option('--latest', 'Return only latest point per unit')
-        .action(async function actionFactsGet(options) {
-        const taxonomyValue = options.taxonomy;
-        if (taxonomyValue && !['us-gaap', 'dei'].includes(taxonomyValue)) {
-            throw new CLIAbortError(emitError({
-                command: 'facts get',
-                err: new CLIError(ErrorCode.VALIDATION_ERROR, '--taxonomy must be us-gaap or dei'),
-                runtimeView: 'summary',
-                humanMode: false,
-                io
-            }));
-        }
-        await executeCommand('facts get', this, io, async (context) => runFactsGet({
-            id: options.id,
-            taxonomy: taxonomyValue,
-            concept: options.concept,
-            unit: options.unit,
-            latest: Boolean(options.latest)
-        }, context));
-    });
-    const research = program
-        .command('research')
-        .description('Run deterministic research workflows over explicit docs or cached filing profiles');
-    research
-        .command('sync')
-        .description('Cache a deterministic research corpus for a company/profile')
-        .requiredOption('--id <id>', 'Ticker or CIK')
-        .option('--profile <profile>', 'core|events|financials', 'core')
-        .option('--cache-dir <path>', 'Override cache directory')
-        .option('--refresh', 'Force refetch even when cached docs exist')
-        .action(async function actionResearchSync(options) {
-        const profile = parseResearchProfile(options.profile);
-        await executeCommand('research sync', this, io, async (context) => runResearchSync({
-            id: options.id,
-            profile,
-            cacheDir: options.cacheDir,
-            refresh: Boolean(options.refresh)
-        }, context), { requiresSecIdentity: true });
-    });
-    research
-        .command('ask')
-        .description('Query explicitly provided local docs, or a cached company profile corpus when --id is used')
-        .argument('<query>', 'Natural language query')
-        .option('--id <id>', 'Ticker or CIK for cached/profile-based research')
-        .option('--profile <profile>', 'core|events|financials (used with --id)', 'core')
-        .option('--form <form>', 'SEC form filter for scoped filing selection with --id, e.g. 10-Q')
-        .option('--latest <n>', 'With --id, limit to latest N filings after filters')
-        .option('--cache-dir <path>', 'Override cache directory')
-        .option('--refresh', 'With --id, force refetch of filings before querying')
-        .option('--doc <path>', 'Path to a local document (repeatable)', collectValues, [])
-        .option('--manifest <path>', 'Path to JSON manifest: either ["doc1", ...] or {"docs": ["doc1", ...]}')
-        .option('--top-k <n>', 'Maximum number of chunks to return', '8')
-        .option('--chunk-lines <n>', 'Number of lines per retrieval chunk', '40')
-        .option('--chunk-overlap <n>', 'Line overlap between retrieval chunks', '10')
-        .action(async function actionResearchAsk(query, options) {
-        const topK = parsePositiveInt(options.topK, '--top-k');
-        const chunkLines = parsePositiveInt(options.chunkLines, '--chunk-lines');
-        const chunkOverlap = parseNonNegativeInt(options.chunkOverlap, '--chunk-overlap');
-        const latest = options.latest === undefined
-            ? undefined
-            : parsePositiveInt(options.latest, '--latest');
-        if (!options.id && (options.form || latest !== undefined)) {
-            throw new CLIAbortError(emitError({
-                command: 'research ask',
-                err: new CLIError(ErrorCode.VALIDATION_ERROR, '--form and --latest require --id'),
-                runtimeView: 'summary',
-                humanMode: false,
-                io
-            }));
-        }
-        const requiresSecIdentity = Boolean(options.id);
-        const profile = parseResearchProfile(options.profile);
-        await executeCommand('research ask', this, io, async (context) => options.id
-            ? runResearchAskById({
-                id: options.id,
-                query,
-                profile,
-                scope: {
-                    form: options.form,
-                    latest
-                },
-                cacheDir: options.cacheDir,
-                refresh: Boolean(options.refresh),
-                topK,
-                chunkLines,
-                chunkOverlap
-            }, context)
-            : runResearchAsk({
-                query,
-                docs: options.doc ?? [],
-                manifestPath: options.manifest,
-                topK,
-                chunkLines,
-                chunkOverlap
-            }, context), { requiresSecIdentity });
-    });
-    return program;
-}
-function collectValues(value, previous) {
-    return [...previous, value];
-}
-export async function runCli(argv, io = defaultIo()) {
-    const program = buildProgram(io);
-    try {
-        await program.parseAsync(argv, { from: 'user' });
-        return 0;
-    }
-    catch (error) {
-        if (error instanceof CLIAbortError) {
-            return error.exitCode;
-        }
-        if (error instanceof CommanderError) {
-            return error.exitCode;
-        }
-        const cliError = toCliError(error);
-        io.stderr(`${cliError.code} ${cliError.message}\n`);
-        return EXIT_CODE_MAP[cliError.code] ?? 10;
-    }
-}
-function isDirectExecution() {
-    const argvPath = process.argv[1];
-    if (!argvPath) {
-        return false;
-    }
-    try {
-        return realpathSync(argvPath) === realpathSync(fileURLToPath(import.meta.url));
-    }
-    catch {
-        return false;
-    }
-}
-if (isDirectExecution()) {
-    runCli(process.argv.slice(2)).then((exitCode) => {
-        process.exit(exitCode);
-    });
-}

package/dist/commands/facts.d.ts

@@ -1,8 +0,0 @@
-import { CommandContext, CommandResult } from '../core/runtime.js';
-export declare function runFactsGet(params: {
-    id: string;
-    taxonomy?: 'us-gaap' | 'dei';
-    concept?: string;
-    unit?: string;
-    latest?: boolean;
-}, context: CommandContext): Promise<CommandResult>;

package/dist/commands/facts.js

@@ -1,125 +0,0 @@
-import { CLIError, ErrorCode } from '../core/errors.js';
-import { companyFactsUrl } from '../sec/endpoints.js';
-import { resolveEntity } from '../sec/ticker-map.js';
-function buildConceptSummary(taxonomyFacts) {
-    return Object.entries(taxonomyFacts)
-        .map(([concept, payload]) => {
-        const units = Object.keys(payload.units ?? {});
-        return {
-            concept,
-            label: payload.label ?? null,
-            unit_count: units.length,
-            units
-        };
-    })
-        .sort((a, b) => a.concept.localeCompare(b.concept));
-}
-function pickLatest(points) {
-    if (points.length === 0) {
-        return null;
-    }
-    const sorted = [...points].sort((a, b) => {
-        const aKey = a.filed ?? a.end ?? '';
-        const bKey = b.filed ?? b.end ?? '';
-        return bKey.localeCompare(aKey);
-    });
-    return sorted[0] ?? null;
-}
-function selectTaxonomy(allFacts, concept, taxonomy) {
-    if (taxonomy) {
-        if (!allFacts[taxonomy]) {
-            throw new CLIError(ErrorCode.NOT_FOUND, `Taxonomy ${taxonomy} not found`);
-        }
-        return taxonomy;
-    }
-    const preferred = ['us-gaap', 'dei'];
-    for (const tax of preferred) {
-        if (allFacts[tax]?.[concept]) {
-            return tax;
-        }
-    }
-    const anyTaxonomy = Object.keys(allFacts).find((tax) => Boolean(allFacts[tax]?.[concept]));
-    if (anyTaxonomy) {
-        return anyTaxonomy;
-    }
-    throw new CLIError(ErrorCode.NOT_FOUND, `Concept ${concept} not found in company facts`);
-}
-export async function runFactsGet(params, context) {
-    const entity = await resolveEntity(params.id, context.secClient, { strictMapMatch: false });
-    const payload = await context.secClient.fetchSecJson(companyFactsUrl(entity.cik));
-    const allFacts = payload.facts ?? {};
-    if (!params.concept) {
-        if (params.taxonomy) {
-            const taxonomyFacts = allFacts[params.taxonomy];
-            if (!taxonomyFacts) {
-                throw new CLIError(ErrorCode.NOT_FOUND, `Taxonomy ${params.taxonomy} not found`);
-            }
-            return {
-                data: {
-                    cik: entity.cik,
-                    entityName: payload.entityName,
-                    taxonomy: params.taxonomy,
-                    concept_count: Object.keys(taxonomyFacts).length,
-                    concepts: buildConceptSummary(taxonomyFacts)
-                }
-            };
-        }
-        const taxonomySummary = Object.fromEntries(Object.entries(allFacts).map(([taxonomy, taxonomyFacts]) => [
-            taxonomy,
-            {
-                concept_count: Object.keys(taxonomyFacts).length
-            }
-        ]));
-        return {
-            data: {
-                cik: entity.cik,
-                entityName: payload.entityName,
-                taxonomies: taxonomySummary
-            }
-        };
-    }
-    const concept = params.concept;
-    const taxonomy = selectTaxonomy(allFacts, concept, params.taxonomy);
-    const conceptData = allFacts[taxonomy]?.[concept];
-    if (!conceptData) {
-        throw new CLIError(ErrorCode.NOT_FOUND, `Concept ${concept} not found in taxonomy ${taxonomy}`);
-    }
-    const rawUnits = conceptData.units ?? {};
-    let selectedUnits;
-    if (params.unit) {
-        if (!rawUnits[params.unit]) {
-            throw new CLIError(ErrorCode.NOT_FOUND, `Unit ${params.unit} not found for ${taxonomy}:${concept}`);
-        }
-        selectedUnits = {
-            [params.unit]: rawUnits[params.unit]
-        };
-    }
-    else {
-        selectedUnits = rawUnits;
-    }
-    if (params.latest) {
-        const latestByUnit = Object.fromEntries(Object.entries(selectedUnits).map(([unitName, points]) => [unitName, pickLatest(points)]));
-        return {
-            data: {
-                cik: entity.cik,
-                entityName: payload.entityName,
-                taxonomy,
-                concept,
-                label: conceptData.label ?? null,
-                description: conceptData.description ?? null,
-                latest: latestByUnit
-            }
-        };
-    }
-    return {
-        data: {
-            cik: entity.cik,
-            entityName: payload.entityName,
-            taxonomy,
-            concept,
-            label: conceptData.label ?? null,
-            description: conceptData.description ?? null,
-            units: selectedUnits
-        }
-    };
-}

package/dist/commands/filings.d.ts

@@ -1,14 +0,0 @@
-import { CommandContext, CommandResult } from '../core/runtime.js';
-export declare function runFilingsList(params: {
-    id: string;
-    form?: string;
-    from?: string;
-    to?: string;
-    queryLimit?: number;
-    offset?: number;
-}, context: CommandContext): Promise<CommandResult>;
-export declare function runFilingsGet(params: {
-    id: string;
-    accession: string;
-    format: 'url' | 'html' | 'text' | 'markdown';
-}, context: CommandContext): Promise<CommandResult>;

package/dist/commands/filings.js

@@ -1,198 +0,0 @@
-import TurndownService from 'turndown';
-import { gfm } from '@joplin/turndown-plugin-gfm';
-import { CLIError, ErrorCode } from '../core/errors.js';
-import { filingDocumentUrl, submissionsUrl } from '../sec/endpoints.js';
-import { dateInRange, normalizeAccession } from '../sec/normalizers.js';
-import { resolveEntity } from '../sec/ticker-map.js';
-function buildMarkdownConverter() {
-    const service = new TurndownService({
-        headingStyle: 'atx',
-        hr: '---',
-        bulletListMarker: '-',
-        codeBlockStyle: 'fenced',
-        fence: '```',
-        emDelimiter: '*',
-        strongDelimiter: '**',
-        linkStyle: 'inlined'
-    });
-    service.use(gfm);
-    service.remove(['script', 'style', 'noscript', 'iframe', 'canvas']);
-    return service;
-}
-const markdownConverter = buildMarkdownConverter();
-function stripInlineXbrlHeaders(content) {
-    return content
-        .replace(/<ix:header[\s\S]*?<\/ix:header>/gi, '')
-        .replace(/<ix:hidden[\s\S]*?<\/ix:hidden>/gi, '')
-        .replace(/<ix:resources[\s\S]*?<\/ix:resources>/gi, '');
-}
-function splitMarkdownTableCells(line) {
-    const trimmed = line.trim();
-    const withoutLeadingPipe = trimmed.startsWith('|') ? trimmed.slice(1) : trimmed;
-    const withoutTrailingPipe = withoutLeadingPipe.endsWith('|')
-        ? withoutLeadingPipe.slice(0, -1)
-        : withoutLeadingPipe;
-    return withoutTrailingPipe.split('|').map((cell) => cell.trim());
-}
-function isMarkdownTableSeparatorLine(line) {
-    const cells = splitMarkdownTableCells(line);
-    if (cells.length === 0) {
-        return false;
-    }
-    return cells.every((cell) => /^:?-{3,}:?$/.test(cell.replace(/\s+/g, '')));
-}
-function collapseLayoutTables(markdown) {
-    const lines = markdown.split('\n');
-    const output = [];
-    for (let idx = 0; idx < lines.length; idx += 1) {
-        const line = lines[idx];
-        if (!line.trimStart().startsWith('|')) {
-            output.push(line);
-            continue;
-        }
-        const tableBlock = [line];
-        while (idx + 1 < lines.length && lines[idx + 1].trimStart().startsWith('|')) {
-            idx += 1;
-            tableBlock.push(lines[idx]);
-        }
-        const hasSeparator = tableBlock.some(isMarkdownTableSeparatorLine);
-        if (!hasSeparator) {
-            output.push(...tableBlock);
-            continue;
-        }
-        const dataRows = tableBlock.filter((row) => !isMarkdownTableSeparatorLine(row));
-        const nonEmptyCellCounts = dataRows.map((row) => splitMarkdownTableCells(row).filter((cell) => cell.length > 0).length);
-        const maxNonEmptyCells = Math.max(...nonEmptyCellCounts, 0);
-        const avgNonEmptyCells = nonEmptyCellCounts.reduce((sum, count) => sum + count, 0) /
-            Math.max(nonEmptyCellCounts.length, 1);
-        const isLayoutTable = maxNonEmptyCells <= 1 || avgNonEmptyCells <= 1.2;
-        if (!isLayoutTable) {
-            output.push(...tableBlock);
-            continue;
-        }
-        const flattenedRows = dataRows
-            .map((row) => splitMarkdownTableCells(row).filter((cell) => cell.length > 0).join(' '))
-            .map((row) => row.replace(/\s+/g, ' ').trim())
-            .filter((row) => row.length > 0);
-        if (flattenedRows.length > 0) {
-            output.push(...flattenedRows, '');
-        }
-    }
-    return output.join('\n').replace(/\n{3,}/g, '\n\n').trim();
-}
-function zipRecentFilings(cik, recent) {
-    if (!recent) {
-        return [];
-    }
-    const accessionNumbers = recent.accessionNumber ?? [];
-    const forms = recent.form ?? [];
-    const filingDates = recent.filingDate ?? [];
-    const reportDates = recent.reportDate ?? [];
-    const primaryDocuments = recent.primaryDocument ?? [];
-    const rowCount = accessionNumbers.length;
-    const rows = [];
-    for (let idx = 0; idx < rowCount; idx += 1) {
-        const accession = accessionNumbers[idx];
-        if (!accession) {
-            continue;
-        }
-        const primaryDocument = primaryDocuments[idx] ?? null;
-        const filingUrl = primaryDocument && primaryDocument.length > 0
-            ? filingDocumentUrl({
-                cik,
-                accession,
-                primaryDocument
-            })
-            : null;
-        rows.push({
-            accession,
-            form: forms[idx] ?? null,
-            filingDate: filingDates[idx] ?? null,
-            reportDate: reportDates[idx] ?? null,
-            primaryDocument,
-            filingUrl
-        });
-    }
-    return rows;
-}
-function extractMarkdownFromHtml(content) {
-    const sanitizedHtml = stripInlineXbrlHeaders(content);
-    const markdown = markdownConverter
-        .turndown(sanitizedHtml)
-        .replace(/\u00a0/g, ' ')
-        .replace(/\r/g, '')
-        .replace(/[ \t]+\n/g, '\n')
-        .replace(/\n[ \t]+/g, '\n')
-        .replace(/\n{3,}/g, '\n\n')
-        .trim();
-    return collapseLayoutTables(markdown);
-}
-export async function runFilingsList(params, context) {
-    const entity = await resolveEntity(params.id, context.secClient, { strictMapMatch: false });
-    const submissions = await context.secClient.fetchSecJson(submissionsUrl(entity.cik));
-    const rows = zipRecentFilings(entity.cik, submissions.filings?.recent);
-    const normalizedForm = params.form?.toUpperCase();
-    const filteredRows = rows.filter((row) => {
-        if (normalizedForm && (row.form ?? '').toUpperCase() !== normalizedForm) {
-            return false;
-        }
-        if (!row.filingDate) {
-            return !params.from && !params.to;
-        }
-        return dateInRange(row.filingDate, params.from, params.to);
-    });
-    const offset = params.offset ?? 0;
-    const queryLimit = params.queryLimit ?? filteredRows.length;
-    const pagedRows = filteredRows.slice(offset, offset + queryLimit);
-    return {
-        data: pagedRows,
-        metaUpdates: {
-            query_total_count: filteredRows.length,
-            query_returned_count: pagedRows.length,
-            query_truncated: offset + pagedRows.length < filteredRows.length,
-            query_offset: offset
-        }
-    };
-}
-export async function runFilingsGet(params, context) {
-    const accession = normalizeAccession(params.accession);
-    const entity = await resolveEntity(params.id, context.secClient, { strictMapMatch: false });
-    const submissions = await context.secClient.fetchSecJson(submissionsUrl(entity.cik));
-    const rows = zipRecentFilings(entity.cik, submissions.filings?.recent);
-    const match = rows.find((row) => row.accession === accession);
-    if (!match) {
-        throw new CLIError(ErrorCode.NOT_FOUND, `Accession ${accession} not found in recent submissions for ${params.id}`);
-    }
-    if (!match.primaryDocument || !match.filingUrl) {
-        throw new CLIError(ErrorCode.NOT_FOUND, `No primary document found for accession ${accession}`);
-    }
-    if (params.format === 'url') {
-        return {
-            data: {
-                accession: match.accession,
-                form: match.form,
-                filingDate: match.filingDate,
-                reportDate: match.reportDate,
-                primaryDocument: match.primaryDocument,
-                url: match.filingUrl
-            }
-        };
-    }
-    const content = await context.secClient.fetchSecText(match.filingUrl);
-    if (params.format === 'html') {
-        return {
-            data: {
-                accession: match.accession,
-                url: match.filingUrl,
-                content
-            }
-        };
-    }
-    return {
-        data: {
-            accession: match.accession,
-            url: match.filingUrl,
-            content: extractMarkdownFromHtml(content)
-        }
-    };
-}