@laitszkin/apollo-toolkit 3.13.2 → 3.14.1

package/dist/lib/tools/enforce-video-aspect-ratio.d.ts

@@ -0,0 +1,2 @@
+import type { ToolContext } from '../types';
+export declare function enforceVideoAspectRatioHandler(args: string[], context: ToolContext): Promise<number>;

package/dist/lib/tools/enforce-video-aspect-ratio.js

@@ -0,0 +1,312 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceVideoAspectRatioHandler = enforceVideoAspectRatioHandler;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function parseArgs(args) {
+    const parsed = {
+        inputVideo: null,
+        outputVideo: null,
+        inPlace: false,
+        targetSize: null,
+        targetWidth: null,
+        targetHeight: null,
+        aspect: null,
+        force: false,
+        ffmpegBin: 'ffmpeg',
+        ffprobeBin: 'ffprobe',
+        help: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--help' || arg === '-h') {
+            parsed.help = true;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            const eqIndex = arg.indexOf('=');
+            let key;
+            let value;
+            if (eqIndex !== -1) {
+                key = arg.slice(2, eqIndex);
+                value = arg.slice(eqIndex + 1);
+            }
+            else {
+                key = arg.slice(2);
+                value = args[++i] || '';
+            }
+            switch (key) {
+                case 'input':
+                case 'input-video':
+                    parsed.inputVideo = value;
+                    break;
+                case 'output':
+                case 'output-video':
+                    parsed.outputVideo = value;
+                    break;
+                case 'in-place':
+                    parsed.inPlace = true;
+                    break;
+                case 'aspect':
+                    parsed.aspect = value;
+                    break;
+                case 'target-size':
+                    parsed.targetSize = value;
+                    break;
+                case 'target-width':
+                    parsed.targetWidth = parseInt(value, 10) || null;
+                    break;
+                case 'target-height':
+                    parsed.targetHeight = parseInt(value, 10) || null;
+                    break;
+                case 'force':
+                    parsed.force = true;
+                    break;
+                case 'ffmpeg-bin':
+                    parsed.ffmpegBin = value;
+                    break;
+                case 'ffprobe-bin':
+                    parsed.ffprobeBin = value;
+                    break;
+            }
+        }
+        else if (!parsed.inputVideo && !arg.startsWith('-')) {
+            parsed.inputVideo = arg;
+        }
+    }
+    return parsed;
+}
+function parseSize(value) {
+    const match = value.trim().toLowerCase().match(/^(\d{2,5})x(\d{2,5})$/);
+    if (!match)
+        throw new Error('Invalid size format. Use WIDTHxHEIGHT, for example 1080x1920.');
+    const width = parseInt(match[1], 10);
+    const height = parseInt(match[2], 10);
+    if (width <= 0 || height <= 0)
+        throw new Error('Width and height must be positive integers.');
+    return { width, height };
+}
+function parseRatio(value) {
+    const match = value.trim().match(/^(\d+):(\d+)$/);
+    if (!match)
+        throw new Error('Invalid aspect ratio format. Use WIDTH:HEIGHT, for example 16:9.');
+    const width = parseInt(match[1], 10);
+    const height = parseInt(match[2], 10);
+    if (width <= 0 || height <= 0)
+        throw new Error('Aspect ratio values must be positive integers.');
+    return { width, height };
+}
+function probeVideoSize(videoPath, ffprobeBin) {
+    const result = (0, node_child_process_1.execSync)(`${ffprobeBin} -v error -select_streams v:0 -show_entries stream=width,height -of json "${videoPath}"`, { encoding: 'utf-8', timeout: 30000 });
+    const payload = JSON.parse(result);
+    const streams = payload.streams;
+    if (!Array.isArray(streams) || streams.length === 0) {
+        throw new Error(`No video stream found in ${videoPath}.`);
+    }
+    const first = streams[0];
+    const width = first.width;
+    const height = first.height;
+    if (typeof width !== 'number' || typeof height !== 'number' || width <= 0 || height <= 0) {
+        throw new Error(`Invalid video dimensions from ffprobe for ${videoPath}.`);
+    }
+    return { width, height };
+}
+function evenFloor(value, minimum = 2) {
+    const floored = value % 2 === 0 ? value : value - 1;
+    return Math.max(floored, minimum);
+}
+function buildVideoFilter(inputWidth, inputHeight, targetWidth, targetHeight) {
+    const sameRatio = inputWidth * targetHeight === inputHeight * targetWidth;
+    const sameSize = inputWidth === targetWidth && inputHeight === targetHeight;
+    if (sameRatio && sameSize)
+        return { filter: null, cropApplied: false };
+    if (sameRatio)
+        return { filter: `scale=${targetWidth}:${targetHeight}`, cropApplied: false };
+    const inputWider = inputWidth * targetHeight > inputHeight * targetWidth;
+    let cropWidth;
+    let cropHeight;
+    if (inputWider) {
+        cropWidth = Math.floor(inputHeight * targetWidth / targetHeight);
+        cropHeight = inputHeight;
+    }
+    else {
+        cropWidth = inputWidth;
+        cropHeight = Math.floor(inputWidth * targetHeight / targetWidth);
+    }
+    cropWidth = Math.min(evenFloor(cropWidth), evenFloor(inputWidth));
+    cropHeight = Math.min(evenFloor(cropHeight), evenFloor(inputHeight));
+    const offsetX = Math.max(Math.floor((inputWidth - cropWidth) / 2), 0);
+    const offsetY = Math.max(Math.floor((inputHeight - cropHeight) / 2), 0);
+    return {
+        filter: `crop=${cropWidth}:${cropHeight}:${offsetX}:${offsetY},scale=${targetWidth}:${targetHeight}`,
+        cropApplied: true,
+    };
+}
+function resolveTargetSize(opts) {
+    if (opts.aspect) {
+        // Aspect ratio mode: derive target size from input
+        // We'll resolve this later in the handler
+        return { width: 0, height: 0 };
+    }
+    if (opts.targetSize && (opts.targetWidth !== null || opts.targetHeight !== null)) {
+        throw new Error('Use either --target-size or --target-width/--target-height, not both.');
+    }
+    if (opts.targetSize)
+        return parseSize(opts.targetSize);
+    const width = opts.targetWidth || parseInt(process.env.TEXT_TO_SHORT_VIDEO_WIDTH || '1080', 10);
+    const height = opts.targetHeight || parseInt(process.env.TEXT_TO_SHORT_VIDEO_HEIGHT || '1920', 10);
+    if (width <= 0 || height <= 0)
+        throw new Error('Target width and height must be positive integers.');
+    return { width, height };
+}
+async function enforceVideoAspectRatioHandler(args, context) {
+    const stdout = context.stdout || process.stdout;
+    const stderr = context.stderr || process.stderr;
+    try {
+        const opts = parseArgs(args);
+        if (opts.help) {
+            stdout.write(`Usage: apltk enforce-video-aspect-ratio [options]
+
+Resize video output to a target aspect ratio or size.
+
+Options:
+  --input, --input-video <path>   Path to input video (required)
+  --output, --output-video <path> Path to output video
+  --in-place                      Overwrite input file
+  --aspect <ratio>                Target aspect ratio, e.g. 9:16 or 16:9
+  --target-size <size>            Target size, e.g. 1080x1920
+  --target-width <px>             Target width
+  --target-height <px>            Target height
+  --force                         Overwrite existing output
+  --ffmpeg-bin <path>             ffmpeg executable (default: ffmpeg)
+  --ffprobe-bin <path>            ffprobe executable (default: ffprobe)
+`);
+            return 0;
+        }
+        if (!opts.inputVideo) {
+            stderr.write('Error: --input-video is required.\n');
+            return 1;
+        }
+        const inputPath = node_path_1.default.resolve(opts.inputVideo);
+        if (!node_fs_1.default.existsSync(inputPath)) {
+            stderr.write(`Error: Input video not found: ${inputPath}\n`);
+            return 1;
+        }
+        if (opts.inPlace && opts.outputVideo) {
+            stderr.write('Error: Do not pass --output-video with --in-place.\n');
+            return 1;
+        }
+        // Validate ffmpeg/ffprobe availability
+        try {
+            (0, node_child_process_1.execSync)(`which ${opts.ffmpegBin}`, { stdio: 'ignore' });
+            (0, node_child_process_1.execSync)(`which ${opts.ffprobeBin}`, { stdio: 'ignore' });
+        }
+        catch {
+            stderr.write(`Error: Missing required commands: ${opts.ffmpegBin}, ${opts.ffprobeBin}\n`);
+            return 1;
+        }
+        const inputSize = probeVideoSize(inputPath, opts.ffprobeBin);
+        // Resolve target dimensions
+        let targetWidth;
+        let targetHeight;
+        if (opts.aspect) {
+            // Derive from aspect ratio based on input dimensions
+            const ratio = parseRatio(opts.aspect);
+            const inputWider = inputSize.width * ratio.height > inputSize.height * ratio.width;
+            if (inputWider) {
+                targetWidth = Math.floor(inputSize.height * ratio.width / ratio.height);
+                targetHeight = inputSize.height;
+            }
+            else {
+                targetWidth = inputSize.width;
+                targetHeight = Math.floor(inputSize.width * ratio.height / ratio.width);
+            }
+            // Ensure even dimensions
+            targetWidth = evenFloor(targetWidth);
+            targetHeight = evenFloor(targetHeight);
+        }
+        else {
+            const target = resolveTargetSize(opts);
+            targetWidth = target.width;
+            targetHeight = target.height;
+        }
+        // Resolve output path
+        let outputPath;
+        let replaceInPlace = false;
+        if (opts.inPlace) {
+            outputPath = node_path_1.default.join(node_path_1.default.dirname(inputPath), `.tmp_${node_path_1.default.basename(inputPath)}`);
+            replaceInPlace = true;
+        }
+        else if (opts.outputVideo) {
+            outputPath = node_path_1.default.resolve(opts.outputVideo);
+            if (outputPath === inputPath) {
+                stderr.write('Error: Output path equals input path. Use --in-place to replace the input file.\n');
+                return 1;
+            }
+        }
+        else {
+            const parsed = node_path_1.default.parse(inputPath);
+            outputPath = node_path_1.default.join(parsed.dir, `${parsed.name}_aspect_fixed.mp4`);
+        }
+        if (!replaceInPlace && node_fs_1.default.existsSync(outputPath) && !opts.force) {
+            stderr.write(`Error: Output already exists: ${outputPath}. Use --force to overwrite.\n`);
+            return 1;
+        }
+        const { filter, cropApplied } = buildVideoFilter(inputSize.width, inputSize.height, targetWidth, targetHeight);
+        if (filter === null) {
+            stdout.write(`[INFO] Video already matches target size and aspect ratio: ${inputSize.width}x${inputSize.height}.\n`);
+            if (!replaceInPlace && outputPath !== inputPath) {
+                node_fs_1.default.mkdirSync(node_path_1.default.dirname(outputPath), { recursive: true });
+                node_fs_1.default.copyFileSync(inputPath, outputPath);
+                stdout.write(`[OK] Copied original video to: ${outputPath}\n`);
+            }
+            return 0;
+        }
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(outputPath), { recursive: true });
+        const ffmpegCmd = [
+            opts.ffmpegBin,
+            '-hide_banner',
+            '-loglevel', 'error',
+            opts.force || replaceInPlace ? '-y' : '-n',
+            '-i', inputPath,
+            '-vf', filter,
+            '-map', '0:v:0',
+            '-map', '0:a?',
+            '-c:v', 'libx264',
+            '-preset', 'medium',
+            '-crf', '18',
+            '-c:a', 'aac',
+            '-movflags', '+faststart',
+            outputPath,
+        ];
+        try {
+            (0, node_child_process_1.execSync)(ffmpegCmd.join(' '), { stdio: 'ignore', timeout: 300000 });
+        }
+        catch (err) {
+            if (replaceInPlace && node_fs_1.default.existsSync(outputPath))
+                node_fs_1.default.unlinkSync(outputPath);
+            const msg = err instanceof Error ? err.message : 'unknown error';
+            throw new Error(`ffmpeg failed: ${msg}`);
+        }
+        if (replaceInPlace) {
+            node_fs_1.default.renameSync(outputPath, inputPath);
+            outputPath = inputPath;
+        }
+        const finalSize = probeVideoSize(outputPath, opts.ffprobeBin);
+        stdout.write(`[OK] Processed video written: ${outputPath}\n` +
+            `[INFO] Input size: ${inputSize.width}x${inputSize.height}\n` +
+            `[INFO] Target size: ${targetWidth}x${targetHeight}\n` +
+            `[INFO] Output size: ${finalSize.width}x${finalSize.height}\n` +
+            `[INFO] Center crop applied: ${cropApplied ? 'yes' : 'no'}\n`);
+        return 0;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : 'Unknown error';
+        stderr.write(`Error: ${msg}\n`);
+        return 1;
+    }
+}

package/dist/lib/tools/extract-conversations.d.ts

@@ -0,0 +1,2 @@
+import type { ToolContext } from '../types';
+export declare function extractConversationsHandler(args: string[], context: ToolContext): Promise<number>;

package/dist/lib/tools/extract-conversations.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractConversationsHandler = extractConversationsHandler;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function getCodexHome() {
+    return process.env.CODEX_HOME || node_path_1.default.join(process.env.HOME || '', '.codex');
+}
+function readSessionsDir(sessionsDir) {
+    if (!node_fs_1.default.existsSync(sessionsDir))
+        return [];
+    const sessions = [];
+    const entries = node_fs_1.default.readdirSync(sessionsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const sessionDir = node_path_1.default.join(sessionsDir, entry.name);
+        const metaFile = node_path_1.default.join(sessionDir, 'session.json');
+        if (!node_fs_1.default.existsSync(metaFile))
+            continue;
+        try {
+            const meta = JSON.parse(node_fs_1.default.readFileSync(metaFile, 'utf8'));
+            sessions.push({
+                id: entry.name,
+                title: meta.title || entry.name,
+                startedAt: meta.startedAt || '',
+                updatedAt: meta.updatedAt || '',
+                messageCount: meta.messages?.length || 0,
+            });
+        }
+        catch {
+            // skip malformed sessions
+        }
+    }
+    return sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+function filterSessionsByHours(sessions, hours) {
+    if (hours <= 0)
+        return sessions;
+    const cutoff = Date.now() - hours * 60 * 60 * 1000;
+    return sessions.filter((s) => {
+        const t = new Date(s.updatedAt).getTime();
+        return !isNaN(t) && t >= cutoff;
+    });
+}
+function extractConversationsHandler(args, context) {
+    try {
+        let hours = 24;
+        let format = 'text';
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] === '--hours' && i + 1 < args.length)
+                hours = parseInt(args[++i], 10) || 24;
+            else if (args[i] === '--format' && i + 1 < args.length) {
+                const val = args[++i];
+                if (val === 'json' || val === 'text')
+                    format = val;
+            }
+        }
+        const codexHome = getCodexHome();
+        const sessionsDir = node_path_1.default.join(codexHome, 'sessions');
+        const archivedDir = node_path_1.default.join(codexHome, 'sessions', '.archived');
+        let sessions = readSessionsDir(sessionsDir);
+        // Also read archived sessions
+        if (node_fs_1.default.existsSync(archivedDir)) {
+            const archived = readSessionsDir(archivedDir);
+            sessions = [...sessions, ...archived];
+        }
+        sessions = filterSessionsByHours(sessions, hours);
+        if (format === 'json') {
+            const output = {
+                totalSessions: sessions.length,
+                hours,
+                sessions: sessions.map((s) => ({
+                    id: s.id,
+                    title: s.title,
+                    startedAt: s.startedAt,
+                    updatedAt: s.updatedAt,
+                    messageCount: s.messageCount,
+                    sessionPath: node_path_1.default.join(sessionsDir, s.id),
+                })),
+            };
+            context.stdout?.write(JSON.stringify(output, null, 2));
+            context.stdout?.write('\n');
+        }
+        else {
+            context.stdout?.write(`Recent Codex sessions (last ${hours}h):\n`);
+            context.stdout?.write(`Found ${sessions.length} sessions\n\n`);
+            for (const session of sessions) {
+                context.stdout?.write(`  [${session.id}] ${session.title}\n`);
+                context.stdout?.write(`    Started: ${session.startedAt}\n`);
+                context.stdout?.write(`    Updated: ${session.updatedAt}\n`);
+                context.stdout?.write(`    Messages: ${session.messageCount}\n\n`);
+            }
+        }
+        return Promise.resolve(0);
+    }
+    catch (err) {
+        const stderr = context.stderr || process.stderr;
+        stderr.write(`Error: ${err.message}\n`);
+        return Promise.resolve(1);
+    }
+}

package/dist/lib/tools/extract-pdf-text.d.ts

@@ -0,0 +1,2 @@
+import type { ToolContext } from '../types';
+export declare function extractPdfTextHandler(args: string[], context: ToolContext): Promise<number>;

package/dist/lib/tools/extract-pdf-text.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPdfTextHandler = extractPdfTextHandler;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+const SWIFT_SCRIPT = [
+    'import Foundation',
+    'import PDFKit',
+    '',
+    'let args = CommandLine.arguments',
+    'guard args.count > 1 else { print("PDF_PATH="); exit(1) }',
+    'let pdfPath = args[1]',
+    'let pdfURL = URL(fileURLWithPath: pdfPath)',
+    'guard let document = PDFDocument(url: pdfURL) else { fputs("Unable to open PDF at \\(pdfPath)\\n", stderr); exit(1) }',
+    'print("PDF_PATH=\\(pdfPath)")',
+    'print("PAGE_COUNT=\\(document.pageCount)")',
+    'for pageIndex in 0..<document.pageCount {',
+    '    guard let page = document.page(at: pageIndex) else { continue }',
+    '    let text = page.string?.replacingOccurrences(of: "\\u{000C}", with: "\\n").trimmingCharacters(in: .whitespacesAndNewlines) ?? ""',
+    '    print("=== PAGE \\(pageIndex + 1) ===")',
+    '    if text.isEmpty { print("[NO_TEXT_EXTRACTED]") } else { print(text) }',
+    '}',
+].join('\n');
+async function extractPdfTextHandler(args, context) {
+    const stdout = context.stdout || process.stdout;
+    const stderr = context.stderr || process.stderr;
+    // Find positional pdfPath arg
+    let pdfPath = '';
+    let showHelp = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--help' || arg === '-h') {
+            showHelp = true;
+            break;
+        }
+        if (!arg.startsWith('-')) {
+            pdfPath = arg;
+        }
+    }
+    if (showHelp || !pdfPath) {
+        stdout.write(`Usage: apltk extract-pdf-text-pdfkit <path>
+
+Extract per-page text from a PDF through macOS PDFKit.
+
+Arguments:
+  path  Absolute path to the source PDF file
+
+Output format:
+  PDF_PATH=<path>
+  PAGE_COUNT=<N>
+  === PAGE 1 ===
+  <page text>
+  === PAGE 2 ===
+  ...
+`);
+        return pdfPath ? 1 : 0;
+    }
+    const resolvedPath = node_path_1.default.resolve(pdfPath);
+    return new Promise((resolve) => {
+        const child = (0, node_child_process_1.spawn)('swift', ['-', resolvedPath], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: context.env || process.env,
+        });
+        // Write the Swift script to stdin for inline execution
+        child.stdin.write(SWIFT_SCRIPT);
+        child.stdin.end();
+        let stdoutText = '';
+        let stderrText = '';
+        child.stdout.on('data', (chunk) => {
+            stdoutText += String(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderrText += String(chunk);
+        });
+        child.on('error', (err) => {
+            stderr.write(`Failed to start swift: ${err.message}\n`);
+            resolve(1);
+        });
+        child.on('close', (code) => {
+            if (stdoutText) {
+                stdout.write(stdoutText);
+            }
+            if (stderrText) {
+                stderr.write(stderrText);
+            }
+            resolve(typeof code === 'number' ? code : 1);
+        });
+    });
+}

package/dist/lib/tools/filter-logs.d.ts

@@ -0,0 +1,2 @@
+import type { ToolContext } from '../types';
+export declare function filterLogsHandler(argv: string[], context: ToolContext): Promise<number>;

package/dist/lib/tools/filter-logs.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterLogsHandler = filterLogsHandler;
+const log_cli_utils_1 = require("./log-cli-utils");
+function parseArgs(argv) {
+    const args = {
+        paths: [],
+        start: null,
+        end: null,
+        assumeTimezone: 'UTC',
+        keepUndated: false,
+        countOnly: false,
+    };
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        if (arg === '--start' && i + 1 < argv.length) {
+            args.start = argv[++i];
+        }
+        else if (arg === '--end' && i + 1 < argv.length) {
+            args.end = argv[++i];
+        }
+        else if (arg === '--assume-timezone' && i + 1 < argv.length) {
+            args.assumeTimezone = argv[++i];
+        }
+        else if (arg === '--keep-undated') {
+            args.keepUndated = true;
+        }
+        else if (arg === '--count-only') {
+            args.countOnly = true;
+        }
+        else if (arg.startsWith('-')) {
+            // skip unknown flags
+        }
+        else {
+            args.paths.push(arg);
+        }
+        i++;
+    }
+    return args;
+}
+async function filterLogsHandler(argv, context) {
+    const { stdout, stderr } = context;
+    const args = parseArgs(argv);
+    let tzOffset;
+    try {
+        tzOffset = (0, log_cli_utils_1.buildTimezone)(args.assumeTimezone);
+    }
+    catch (err) {
+        stderr.write(`Error: invalid timezone: ${args.assumeTimezone}\n`);
+        return 1;
+    }
+    let start = null;
+    let end = null;
+    try {
+        if (args.start) {
+            start = (0, log_cli_utils_1.parseCliTimestamp)(args.start, args.assumeTimezone);
+        }
+        if (args.end) {
+            end = (0, log_cli_utils_1.parseCliTimestamp)(args.end, args.assumeTimezone);
+        }
+    }
+    catch (err) {
+        stderr.write(`Error: ${err.message}\n`);
+        return 1;
+    }
+    if (!(0, log_cli_utils_1.validateTimeWindow)(start, end, stderr)) {
+        return 1;
+    }
+    let matches = 0;
+    try {
+        for await (const line of (0, log_cli_utils_1.iterInputLines)(args.paths)) {
+            const timestamp = (0, log_cli_utils_1.extractTimestamp)(line, args.assumeTimezone);
+            if (timestamp === null && !args.keepUndated) {
+                continue;
+            }
+            if (timestamp !== null && !(0, log_cli_utils_1.inWindow)(timestamp, start, end)) {
+                continue;
+            }
+            matches++;
+            if (!args.countOnly) {
+                stdout.write(line + '\n');
+            }
+        }
+    }
+    catch (err) {
+        stderr.write(`Error: ${err.message}\n`);
+        return 1;
+    }
+    if (args.countOnly) {
+        stdout.write(String(matches) + '\n');
+    }
+    return 0;
+}

package/dist/lib/tools/find-github-issues.d.ts

@@ -0,0 +1,2 @@
+import type { ToolContext } from '../types';
+export declare function findGitHubIssuesHandler(argv: string[], context: ToolContext): Promise<number>;