@laitszkin/apollo-toolkit 3.13.2 → 3.14.1

package/dist/lib/tools/review-threads.js

@@ -0,0 +1,491 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviewThreadsHandler = reviewThreadsHandler;
+// @ts-nocheck
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const LIST_QUERY = `
+query($owner: String!, $name: String!, $number: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      reviewThreads(first: 100, after: $after) {
+        nodes {
+          id
+          isResolved
+          isOutdated
+          path
+          line
+          startLine
+          comments(first: 20) {
+            nodes {
+              id
+              url
+              body
+              author {
+                login
+              }
+              createdAt
+              path
+              line
+              outdated
+            }
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  }
+}
+`;
+const RESOLVE_MUTATION = `
+mutation($threadId: ID!) {
+  resolveReviewThread(input: {threadId: $threadId}) {
+    thread {
+      id
+      isResolved
+    }
+  }
+}
+`;
+function parseArgs(argv) {
+    const args = {
+        command: '',
+        repo: null,
+        pr: null,
+        state: 'unresolved',
+        output: 'table',
+        threadId: [],
+        threadIdFile: null,
+        allUnresolved: false,
+        dryRun: false,
+    };
+    // First argument is the subcommand (list/resolve)
+    let i = 0;
+    if (i < argv.length && !argv[i].startsWith('-')) {
+        args.command = argv[i++];
+    }
+    while (i < argv.length) {
+        const arg = argv[i];
+        switch (arg) {
+            case '--repo':
+                if (i + 1 < argv.length)
+                    args.repo = argv[++i];
+                break;
+            case '--pr':
+                if (i + 1 < argv.length) {
+                    const n = parseInt(argv[++i], 10);
+                    if (n > 0)
+                        args.pr = n;
+                }
+                break;
+            case '--state':
+                if (i + 1 < argv.length) {
+                    const val = argv[++i];
+                    if (['unresolved', 'resolved', 'all'].includes(val))
+                        args.state = val;
+                }
+                break;
+            case '--output':
+                if (i + 1 < argv.length) {
+                    const val = argv[++i];
+                    if (val === 'table' || val === 'json')
+                        args.output = val;
+                }
+                break;
+            case '--thread-id':
+                if (i + 1 < argv.length)
+                    args.threadId.push(argv[++i]);
+                break;
+            case '--thread-id-file':
+                if (i + 1 < argv.length)
+                    args.threadIdFile = argv[++i];
+                break;
+            case '--all-unresolved':
+                args.allUnresolved = true;
+                break;
+            case '--dry-run':
+                args.dryRun = true;
+                break;
+            default:
+                break;
+        }
+        i++;
+    }
+    return args;
+}
+function runGh(cmdArgs) {
+    return new Promise((resolve) => {
+        (0, node_child_process_1.execFile)('gh', cmdArgs, { maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+            if (error) {
+                resolve({
+                    stdout: stdout || '',
+                    stderr: stderr || '',
+                    exitCode: error.status ?? 1,
+                });
+            }
+            else {
+                resolve({ stdout: stdout || '', stderr: stderr || '', exitCode: 0 });
+            }
+        });
+    });
+}
+function runGhJson(cmdArgs) {
+    return runGh(cmdArgs).then((result) => {
+        if (result.exitCode !== 0) {
+            throw new Error(result.stderr.trim() || 'gh command failed');
+        }
+        try {
+            return JSON.parse(result.stdout);
+        }
+        catch (exc) {
+            throw new Error('Failed to parse gh JSON output');
+        }
+    });
+}
+function parseOwnerRepo(repo) {
+    const parts = repo.split('/');
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+        throw new Error('repo must be in owner/name format');
+    }
+    return [parts[0], parts[1]];
+}
+async function resolveRepo(repo) {
+    if (repo) {
+        parseOwnerRepo(repo);
+        return repo;
+    }
+    const result = await runGh([
+        'repo',
+        'view',
+        '--json',
+        'nameWithOwner',
+        '--jq',
+        '.nameWithOwner',
+    ]);
+    if (result.exitCode !== 0) {
+        throw new Error(result.stderr.trim() || 'Unable to resolve current repo');
+    }
+    return result.stdout.trim();
+}
+async function resolvePrNumber(repo, pr) {
+    if (pr !== null)
+        return pr;
+    const result = await runGh([
+        'pr',
+        'view',
+        '--repo',
+        repo,
+        '--json',
+        'number',
+        '--jq',
+        '.number',
+    ]);
+    if (result.exitCode !== 0) {
+        throw new Error('Unable to infer PR number from current branch context');
+    }
+    return parseInt(result.stdout.trim(), 10);
+}
+function ghGraphql(query, variables) {
+    const cmdArgs = ['api', 'graphql', '-f', `query=${query}`];
+    for (const [key, value] of Object.entries(variables)) {
+        cmdArgs.push('-F', `${key}=${JSON.stringify(value)}`);
+    }
+    return runGhJson(cmdArgs);
+}
+// ---- Thread fetching ----
+async function fetchReviewThreads(repo, prNumber) {
+    const [owner, name] = parseOwnerRepo(repo);
+    const threads = [];
+    let after = null;
+    while (true) {
+        const payload = await ghGraphql(LIST_QUERY, {
+            owner,
+            name,
+            number: prNumber,
+            after,
+        });
+        const pr = payload.data?.repository;
+        if (!pr) {
+            throw new Error(`PR #${prNumber} not found in ${repo}`);
+        }
+        const reviewThreads = pr.reviewThreads;
+        const nodes = reviewThreads.nodes || [];
+        threads.push(...nodes);
+        const pageInfo = reviewThreads.pageInfo;
+        if (!pageInfo.hasNextPage)
+            break;
+        after = pageInfo.endCursor || null;
+        if (!after)
+            break;
+    }
+    return threads;
+}
+function filterThreads(threads, state) {
+    if (state === 'all')
+        return threads;
+    if (state === 'resolved') {
+        return threads.filter((item) => item.isResolved);
+    }
+    return threads.filter((item) => !item.isResolved);
+}
+function normalizeThread(thread) {
+    const commentNodes = thread.comments?.nodes;
+    const normalizedComments = (commentNodes || []).map((comment) => ({
+        id: comment.id,
+        url: comment.url,
+        author: comment.author?.login || null,
+        body: comment.body || '',
+        created_at: comment.createdAt,
+        path: comment.path,
+        line: comment.line,
+        outdated: comment.outdated,
+    }));
+    return {
+        thread_id: thread.id,
+        is_resolved: thread.isResolved,
+        is_outdated: thread.isOutdated,
+        path: thread.path,
+        line: thread.line,
+        start_line: thread.startLine,
+        comments: normalizedComments,
+    };
+}
+function truncate(text, width) {
+    if (text.length <= width)
+        return text;
+    if (width <= 3)
+        return text.slice(0, width);
+    return text.slice(0, width - 3) + '...';
+}
+function previewBody(thread) {
+    const comments = thread.comments;
+    if (!comments || comments.length === 0)
+        return '-';
+    const body = (comments[0].body || '').replace(/\n/g, ' ').trim();
+    return truncate(body || '-', 72);
+}
+function renderLocation(thread) {
+    const path = thread.path || '-';
+    const line = thread.line;
+    if (line == null)
+        return path;
+    return `${path}:${line}`;
+}
+function printTable(threads, context) {
+    const { stdout } = context;
+    const widths = {
+        idx: 4,
+        thread: 12,
+        location: 36,
+        author: 18,
+        preview: 72,
+    };
+    const header = `${'#'.padEnd(widths.idx)} ` +
+        `${'THREAD_ID'.padEnd(widths.thread)} ` +
+        `${'LOCATION'.padEnd(widths.location)} ` +
+        `${'AUTHOR'.padEnd(widths.author)} ` +
+        `${'COMMENT_PREVIEW'.padEnd(widths.preview)}`;
+    stdout.write(header + '\n');
+    stdout.write('-'.repeat(header.length) + '\n');
+    for (let idx = 0; idx < threads.length; idx++) {
+        const thread = threads[idx];
+        const comments = thread.comments;
+        const author = comments?.[0]?.author ?? '-';
+        const row = `${String(idx + 1).padEnd(widths.idx)} ` +
+            `${truncate(String(thread.thread_id ?? '-'), widths.thread).padEnd(widths.thread)} ` +
+            `${truncate(renderLocation(thread), widths.location).padEnd(widths.location)} ` +
+            `${truncate(String(author ?? '-'), widths.author).padEnd(widths.author)} ` +
+            `${previewBody(thread).padEnd(widths.preview)}`;
+        stdout.write(row + '\n');
+    }
+}
+// ---- Thread ID loading ----
+function loadThreadIds(filePath) {
+    const raw = (0, node_fs_1.readFileSync)(filePath, 'utf-8');
+    const payload = JSON.parse(raw);
+    let ids;
+    if (Array.isArray(payload)) {
+        ids = payload;
+    }
+    else if (typeof payload === 'object' && payload !== null) {
+        const p = payload;
+        if (Array.isArray(p.thread_ids)) {
+            ids = p.thread_ids;
+        }
+        else if (Array.isArray(p.adopted_thread_ids)) {
+            ids = p.adopted_thread_ids;
+        }
+        else if (Array.isArray(p.threads)) {
+            ids = p.threads
+                .filter((item) => typeof item === 'object' && item !== null)
+                .map((item) => item.thread_id)
+                .filter((id) => id !== undefined);
+        }
+        else {
+            throw new Error('JSON must include thread_ids, adopted_thread_ids, or threads');
+        }
+    }
+    else {
+        throw new Error('Unsupported JSON payload for thread IDs');
+    }
+    const output = ids
+        .filter((item) => typeof item === 'string' && item.trim().length > 0)
+        .map((item) => item.trim());
+    return [...new Set(output)];
+}
+function collectThreadIds(args, unresolvedThreads) {
+    const ids = [];
+    if (args.allUnresolved) {
+        for (const item of unresolvedThreads) {
+            if (item.thread_id) {
+                ids.push(item.thread_id);
+            }
+        }
+    }
+    ids.push(...args.threadId);
+    if (args.threadIdFile) {
+        ids.push(...loadThreadIds(args.threadIdFile));
+    }
+    const normalized = ids.filter(Boolean);
+    return [...new Set(normalized)];
+}
+async function resolveThreads(threadIds, dryRun) {
+    const resolved = [];
+    const failed = [];
+    for (const threadId of threadIds) {
+        if (dryRun) {
+            resolved.push(threadId);
+            continue;
+        }
+        try {
+            const payload = await ghGraphql(RESOLVE_MUTATION, { threadId });
+            const thread = payload.data?.resolveReviewThread;
+            if (!thread?.thread) {
+                throw new Error('thread did not resolve');
+            }
+            const resolvedThread = thread.thread;
+            if (!resolvedThread.isResolved) {
+                throw new Error('thread did not resolve');
+            }
+            resolved.push(threadId);
+        }
+        catch (exc) {
+            failed.push({ thread_id: threadId, error: exc.message });
+        }
+    }
+    return { resolved, failed };
+}
+// ---- Subcommands ----
+async function cmdList(args, context) {
+    const { stdout, stderr } = context;
+    let repo;
+    try {
+        repo = await resolveRepo(args.repo);
+    }
+    catch (err) {
+        stderr.write(`Error: ${err.message}\n`);
+        return 1;
+    }
+    let prNumber;
+    try {
+        prNumber = await resolvePrNumber(repo, args.pr);
+    }
+    catch (err) {
+        stderr.write(`Error: ${err.message}\n`);
+        return 1;
+    }
+    let threads;
+    try {
+        threads = await fetchReviewThreads(repo, prNumber);
+    }
+    catch (err) {
+        stderr.write(`Error: ${err.message}\n`);
+        return 1;
+    }
+    const filtered = filterThreads(threads, args.state);
+    const normalized = filtered.map(normalizeThread);
+    const result = {
+        repo,
+        pr_number: prNumber,
+        state: args.state,
+        thread_count: normalized.length,
+        threads: normalized,
+    };
+    if (args.output === 'json') {
+        stdout.write(JSON.stringify(result, null, 2) + '\n');
+    }
+    else {
+        stdout.write(`Repository: ${repo}\n`);
+        stdout.write(`PR: #${prNumber}\n`);
+        stdout.write(`Threads (${args.state}): ${normalized.length}\n`);
+        printTable(normalized, context);
+    }
+    return 0;
+}
+async function cmdResolve(args, context) {
+    const { stdout, stderr } = context;
+    let repo;
+    try {
+        repo = await resolveRepo(args.repo);
+    }
+    catch (err) {
+        stderr.write(`Error: ${err.message}\n`);
+        return 1;
+    }
+    let prNumber;
+    try {
+        prNumber = await resolvePrNumber(repo, args.pr);
+    }
+    catch (err) {
+        stderr.write(`Error: ${err.message}\n`);
+        return 1;
+    }
+    let threads;
+    try {
+        threads = await fetchReviewThreads(repo, prNumber);
+    }
+    catch (err) {
+        stderr.write(`Error: ${err.message}\n`);
+        return 1;
+    }
+    const unresolved = filterThreads(threads, 'unresolved').map(normalizeThread);
+    const threadIds = collectThreadIds(args, unresolved);
+    if (threadIds.length === 0) {
+        stderr.write('Error: no thread IDs selected. Use --thread-id, --thread-id-file, or --all-unresolved.\n');
+        return 1;
+    }
+    const { resolved, failed } = await resolveThreads(threadIds, args.dryRun);
+    const summary = {
+        repo,
+        pr_number: prNumber,
+        requested: threadIds,
+        resolved,
+        failed,
+        dry_run: args.dryRun,
+    };
+    stdout.write(JSON.stringify(summary, null, 2) + '\n');
+    return failed.length > 0 ? 1 : 0;
+}
+// ---- Main handler ----
+async function reviewThreadsHandler(argv, context) {
+    const { stderr } = context;
+    const args = parseArgs(argv);
+    try {
+        switch (args.command) {
+            case 'list':
+                return await cmdList(args, context);
+            case 'resolve':
+                return await cmdResolve(args, context);
+            default:
+                stderr.write(`Unsupported command: ${args.command}\n`);
+                return 1;
+        }
+    }
+    catch (err) {
+        stderr.write(`Error: ${err.message}\n`);
+        return 1;
+    }
+}

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

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

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchLogsHandler = searchLogsHandler;
+const log_cli_utils_1 = require("./log-cli-utils");
+function parseArgs(argv) {
+    const args = {
+        paths: [],
+        keyword: [],
+        regex: [],
+        mode: 'any',
+        ignoreCase: false,
+        start: null,
+        end: null,
+        assumeTimezone: 'UTC',
+        beforeContext: 0,
+        afterContext: 0,
+        countOnly: false,
+    };
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        if (arg === '--keyword' && i + 1 < argv.length) {
+            args.keyword.push(argv[++i]);
+        }
+        else if (arg === '--regex' && i + 1 < argv.length) {
+            args.regex.push(argv[++i]);
+        }
+        else if (arg === '--mode' && i + 1 < argv.length) {
+            const val = argv[++i];
+            if (val === 'any' || val === 'all') {
+                args.mode = val;
+            }
+        }
+        else if (arg === '--ignore-case') {
+            args.ignoreCase = true;
+        }
+        else 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 === '--before-context' && i + 1 < argv.length) {
+            args.beforeContext = parseInt(argv[++i], 10) || 0;
+        }
+        else if (arg === '--after-context' && i + 1 < argv.length) {
+            args.afterContext = parseInt(argv[++i], 10) || 0;
+        }
+        else if (arg === '--count-only') {
+            args.countOnly = true;
+        }
+        else if (arg.startsWith('-')) {
+            // skip unknown flags
+        }
+        else {
+            args.paths.push(arg);
+        }
+        i++;
+    }
+    return args;
+}
+function buildMatchers(args) {
+    const matchers = [];
+    for (const keyword of args.keyword) {
+        const needle = args.ignoreCase ? keyword.toLowerCase() : keyword;
+        matchers.push((line) => {
+            const haystack = args.ignoreCase ? line.toLowerCase() : line;
+            return haystack.includes(needle);
+        });
+    }
+    for (const pattern of args.regex) {
+        const flags = args.ignoreCase ? 'i' : '';
+        const compiled = new RegExp(pattern, flags);
+        matchers.push((line) => compiled.test(line));
+    }
+    return matchers;
+}
+function lineMatches(line, matchers, mode) {
+    if (matchers.length === 0)
+        return true;
+    if (mode === 'any') {
+        return matchers.some((m) => m(line));
+    }
+    return matchers.every((m) => m(line));
+}
+async function searchLogsHandler(argv, context) {
+    const { stdout, stderr } = context;
+    const args = parseArgs(argv);
+    try {
+        (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;
+    }
+    const matchers = buildMatchers(args);
+    let matches = 0;
+    const beforeBuffer = [];
+    let afterRemaining = 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);
+            // When time filter is active, skip lines outside the window
+            if (args.start || args.end) {
+                if (!(0, log_cli_utils_1.inWindow)(timestamp, start, end)) {
+                    beforeBuffer.push(line);
+                    if (beforeBuffer.length > args.beforeContext) {
+                        beforeBuffer.shift();
+                    }
+                    continue;
+                }
+            }
+            const isMatch = lineMatches(line, matchers, args.mode);
+            if (isMatch) {
+                matches++;
+                if (!args.countOnly) {
+                    // Flush before context
+                    for (const ctxLine of beforeBuffer) {
+                        stdout.write(ctxLine + '\n');
+                    }
+                    stdout.write(line + '\n');
+                }
+                afterRemaining = args.afterContext;
+            }
+            else if (afterRemaining > 0 && !args.countOnly) {
+                stdout.write(line + '\n');
+                afterRemaining--;
+            }
+            // Maintain before context buffer
+            beforeBuffer.push(line);
+            if (beforeBuffer.length > args.beforeContext) {
+                beforeBuffer.shift();
+            }
+        }
+    }
+    catch (err) {
+        stderr.write(`Error: ${err.message}\n`);
+        return 1;
+    }
+    if (args.countOnly) {
+        stdout.write(String(matches) + '\n');
+    }
+    return 0;
+}

package/dist/lib/tools/sync-memory-index.d.ts

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